@types/three 0.180.0 → 0.182.0

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

@@ -1,7 +1,6 @@
 import { Vector3 } from "../../math/Vector3.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import OperatorNode from "./OperatorNode.js";
 
 export type MathNodeMethod1 =
@@ -130,14 +129,22 @@ export default class MathNode extends TempNode {
     constructor(method: MathNodeMethod3, aNode: Node, bNode: Node, cNode: Node);
 }
 
-export const EPSILON: ShaderNodeObject<Node>;
-export const INFINITY: ShaderNodeObject<Node>;
-export const PI: ShaderNodeObject<Node>;
-export const PI2: ShaderNodeObject<Node>;
+export const EPSILON: Node;
+export const INFINITY: Node;
+export const PI: Node;
+
+/**
+ * @deprecated Please use the non-deprecated version `TWO_PI`.
+ */
+export const PI2: Node;
+
+export const TWO_PI: Node;
+
+export const HALF_PI: Node;
 
 type MathNodeParameter = Node | number;
 
-type Unary = (a: MathNodeParameter) => ShaderNodeObject<MathNode>;
+type Unary = (a: MathNodeParameter) => MathNode;
 
 export const all: Unary;
 export const any: Unary;
@@ -157,14 +164,14 @@ export const sqrt: Unary;
 export const inverseSqrt: Unary;
 export const floor: Unary;
 export const ceil: Unary;
-export const normalize: (a: Node | Vector3) => ShaderNodeObject<MathNode>;
+export const normalize: (a: Node | Vector3) => MathNode;
 export const fract: Unary;
 export const sin: Unary;
 export const cos: Unary;
 export const tan: Unary;
 export const asin: Unary;
 export const acos: Unary;
-export const atan: (a: MathNodeParameter, b?: MathNodeParameter) => ShaderNodeObject<MathNode>;
+export const atan: (a: MathNodeParameter, b?: MathNodeParameter) => MathNode;
 export const abs: Unary;
 export const sign: Unary;
 export const length: Unary;
@@ -177,27 +184,27 @@ export const reciprocal: Unary;
 export const trunc: Unary;
 export const fwidth: Unary;
 export const transpose: Unary;
-export const determinant: (x: Node) => ShaderNodeObject<MathNode>;
-export const inverse: (x: Node) => ShaderNodeObject<MathNode>;
+export const determinant: (x: Node) => MathNode;
+export const inverse: (x: Node) => MathNode;
 
-type Binary = (a: MathNodeParameter, b: MathNodeParameter) => ShaderNodeObject<MathNode>;
+type Binary = (a: MathNodeParameter, b: MathNodeParameter) => MathNode;
 
 export const min: (
     x: MathNodeParameter,
     y: MathNodeParameter,
     ...values: MathNodeParameter[]
-) => ShaderNodeObject<MathNode>;
+) => MathNode;
 export const max: (
     x: MathNodeParameter,
     y: MathNodeParameter,
     ...values: MathNodeParameter[]
-) => ShaderNodeObject<MathNode>;
+) => MathNode;
 export const step: Binary;
 export const reflect: Binary;
 export const distance: Binary;
 export const difference: Binary;
 export const dot: Binary;
-export const cross: (x: Node, y: Node) => ShaderNodeObject<MathNode>;
+export const cross: (x: Node, y: Node) => MathNode;
 export const pow: Binary;
 export const pow2: Unary;
 export const pow3: Unary;
@@ -206,20 +213,20 @@ export const transformDirection: Binary;
 export const cbrt: Unary;
 export const lengthSq: Unary;
 
-type Ternary = (a: MathNodeParameter, b: MathNodeParameter, c: MathNodeParameter) => ShaderNodeObject<MathNode>;
+type Ternary = (a: MathNodeParameter, b: MathNodeParameter, c: MathNodeParameter) => MathNode;
 
 export const mix: Ternary;
 export const clamp: (
     a: MathNodeParameter,
     b?: MathNodeParameter,
     c?: MathNodeParameter,
-) => ShaderNodeObject<MathNode>;
+) => MathNode;
 export const saturate: Unary;
 export const refract: Ternary;
 export const smoothstep: Ternary;
 export const faceForward: Ternary;
 
-export const rand: (uv: MathNodeParameter) => ShaderNodeObject<OperatorNode>;
+export const rand: (uv: MathNodeParameter) => OperatorNode;
 
 export const mixElement: Ternary;
 export const smoothstepElement: Ternary;
@@ -237,65 +244,204 @@ export const inversesqrt: typeof inverseSqrt;
 
 // Method chaining
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        all: typeof all;
-        any: typeof any;
-        equals: typeof equals;
-        radians: typeof radians;
-        degrees: typeof degrees;
-        exp: typeof exp;
-        exp2: typeof exp2;
-        log: typeof log;
-        log2: typeof log2;
-        sqrt: typeof sqrt;
-        inverseSqrt: typeof inverseSqrt;
-        floor: typeof floor;
-        ceil: typeof ceil;
-        normalize: typeof normalize;
-        fract: typeof fract;
-        sin: typeof sin;
-        cos: typeof cos;
-        tan: typeof tan;
-        asin: typeof asin;
-        acos: typeof acos;
-        atan: typeof atan;
-        abs: typeof abs;
-        sign: typeof sign;
-        length: typeof length;
-        lengthSq: typeof lengthSq;
-        negate: typeof negate;
-        oneMinus: typeof oneMinus;
-        dFdx: typeof dFdx;
-        dFdy: typeof dFdy;
-        round: typeof round;
-        reciprocal: typeof reciprocal;
-        trunc: typeof trunc;
-        fwidth: typeof fwidth;
-        atan2: typeof atan2;
-        min: typeof min;
-        max: typeof max;
-        step: typeof stepElement;
-        reflect: typeof reflect;
-        distance: typeof distance;
-        dot: typeof dot;
-        cross: typeof cross;
-        pow: typeof pow;
-        pow2: typeof pow2;
-        pow3: typeof pow3;
-        pow4: typeof pow4;
-        transformDirection: typeof transformDirection;
-        mix: typeof mixElement;
-        clamp: typeof clamp;
-        refract: typeof refract;
-        smoothstep: typeof smoothstepElement;
-        faceForward: typeof faceForward;
-        difference: typeof difference;
-        saturate: typeof saturate;
-        cbrt: typeof cbrt;
-        transpose: typeof transpose;
-        determinant: typeof determinant;
-        inverse: typeof inverse;
-        rand: typeof rand;
+declare module "../Nodes.js" {
+    interface Node {
+        all: () => MathNode;
+        allAssign: () => this;
+
+        any: () => MathNode;
+        anyAssign: () => this;
+
+        /**
+         * @deprecated "equals" is deprecated. Use "equal" inside a vector instead, like: "bvec*( equal( ... ) )"
+         */
+        equals: () => MathNode;
+        /**
+         * @deprecated "equals" is deprecated. Use "equal" inside a vector instead, like: "bvec*( equal( ... ) )"
+         */
+        equalsAssign: () => this;
+
+        radians: () => MathNode;
+        radiansAssign: () => this;
+
+        degrees: () => MathNode;
+        degreesAssign: () => this;
+
+        exp: () => MathNode;
+        expAssign: () => this;
+
+        exp2: () => MathNode;
+        exp2Assign: () => this;
+
+        log: () => MathNode;
+        logAssign: () => this;
+
+        log2: () => MathNode;
+        log2Assign: () => this;
+
+        sqrt: () => MathNode;
+        sqrtAssign: () => this;
+
+        inverseSqrt: () => MathNode;
+        inverseSqrtAssign: () => this;
+
+        floor: () => MathNode;
+        floorAssign: () => this;
+
+        ceil: () => MathNode;
+        ceilAssign: () => this;
+
+        normalize: () => MathNode;
+        normalizeAssign: () => this;
+
+        fract: () => MathNode;
+        fractAssign: () => this;
+
+        sin: () => MathNode;
+        sinAssign: () => this;
+
+        cos: () => MathNode;
+        cosAssign: () => this;
+
+        tan: () => MathNode;
+        tanAssign: () => this;
+
+        asin: () => MathNode;
+        asinAssign: () => this;
+
+        acos: () => MathNode;
+        acosAssign: () => this;
+
+        atan: (b?: MathNodeParameter) => MathNode;
+        atanAssign: (b?: MathNodeParameter) => this;
+
+        abs: () => MathNode;
+        absAssign: () => this;
+
+        sign: () => MathNode;
+        signAssign: () => this;
+
+        length: () => MathNode;
+        lengthAssign: () => this;
+
+        lengthSq: () => MathNode;
+        lengthSqAssign: () => this;
+
+        negate: () => MathNode;
+        negateAssign: () => this;
+
+        oneMinus: () => MathNode;
+        oneMinusAssign: () => this;
+
+        dFdx: () => MathNode;
+        dFdxAssign: () => this;
+
+        dFdy: () => MathNode;
+        dFdyAssign: () => this;
+
+        round: () => MathNode;
+        roundAssign: () => this;
+
+        reciprocal: () => MathNode;
+        reciprocalAssign: () => this;
+
+        trunc: () => MathNode;
+        truncAssign: () => this;
+
+        fwidth: () => MathNode;
+        fwidthAssign: () => this;
+
+        /**
+         * @deprecated
+         */
+        atan2: (b: MathNodeParameter) => MathNode;
+        /**
+         * @deprecated
+         */
+        atan2Assign: (b: MathNodeParameter) => this;
+
+        min: (
+            y: MathNodeParameter,
+            ...values: MathNodeParameter[]
+        ) => MathNode;
+        minAssign: (
+            y: MathNodeParameter,
+            ...values: MathNodeParameter[]
+        ) => this;
+
+        max: (
+            y: MathNodeParameter,
+            ...values: MathNodeParameter[]
+        ) => MathNode;
+        maxAssign: (
+            y: MathNodeParameter,
+            ...values: MathNodeParameter[]
+        ) => this;
+
+        step: (b: MathNodeParameter) => MathNode;
+        stepAssign: (b: MathNodeParameter) => this;
+
+        reflect: (b: MathNodeParameter) => MathNode;
+        reflectAssign: (b: MathNodeParameter) => this;
+
+        distance: (b: MathNodeParameter) => MathNode;
+        distanceAssign: (b: MathNodeParameter) => this;
+
+        dot: (b: MathNodeParameter) => MathNode;
+        dotAssign: (b: MathNodeParameter) => this;
+
+        cross: (y: Node) => MathNode;
+        crossAssign: (y: Node) => this;
+
+        pow: (b: MathNodeParameter) => MathNode;
+        powAssign: (b: MathNodeParameter) => this;
+
+        pow2: () => MathNode;
+        pow2Assign: () => this;
+
+        pow3: () => MathNode;
+        pow3Assign: () => this;
+
+        pow4: () => MathNode;
+        pow4Assign: () => this;
+
+        transformDirection: (b: MathNodeParameter) => MathNode;
+        transformDirectionAssign: (b: MathNodeParameter) => this;
+
+        mix: (b: MathNodeParameter, c: MathNodeParameter) => MathNode;
+        mixAssign: (b: MathNodeParameter, c: MathNodeParameter) => this;
+
+        clamp: (b?: MathNodeParameter, c?: MathNodeParameter) => MathNode;
+        clampAssign: (b?: MathNodeParameter, c?: MathNodeParameter) => this;
+
+        refract: (b: MathNodeParameter, c: MathNodeParameter) => MathNode;
+        refractAssign: (b: MathNodeParameter, c: MathNodeParameter) => this;
+
+        smoothstep: (b: MathNodeParameter, c: MathNodeParameter) => MathNode;
+        smoothstepAssign: (b: MathNodeParameter, c: MathNodeParameter) => this;
+
+        faceForward: (b: MathNodeParameter, c: MathNodeParameter) => MathNode;
+        faceForwardAssign: (b: MathNodeParameter, c: MathNodeParameter) => this;
+
+        difference: (b: MathNodeParameter) => MathNode;
+        differenceAssign: (b: MathNodeParameter) => this;
+
+        saturate: () => MathNode;
+        saturateAssign: () => this;
+
+        cbrt: () => MathNode;
+        cbrtAssign: () => this;
+
+        transpose: () => MathNode;
+        transposeAssign: () => this;
+
+        determinant: () => MathNode;
+        determinantAssign: () => this;
+
+        inverse: () => MathNode;
+        inverseAssign: () => this;
+
+        rand: () => OperatorNode;
+        randAssign: () => this;
     }
 }

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

@@ -1,6 +1,5 @@
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type OperatorNodeOp =
     | "%"
@@ -39,93 +38,238 @@ export const add: (
     a: OperatorNodeParameter,
     b: OperatorNodeParameter,
     ...params: OperatorNodeParameter[]
-) => ShaderNodeObject<OperatorNode>;
+) => OperatorNode;
 export const sub: (
     a: OperatorNodeParameter,
     b: OperatorNodeParameter,
     ...params: OperatorNodeParameter[]
-) => ShaderNodeObject<OperatorNode>;
+) => OperatorNode;
 export const mul: (
     a: OperatorNodeParameter,
     b: OperatorNodeParameter,
     ...params: OperatorNodeParameter[]
-) => ShaderNodeObject<OperatorNode>;
+) => OperatorNode;
 export const div: (
     a: OperatorNodeParameter,
     b: OperatorNodeParameter,
     ...params: OperatorNodeParameter[]
-) => ShaderNodeObject<OperatorNode>;
-export const mod: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const equal: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const notEqual: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const lessThan: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const greaterThan: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const lessThanEqual: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const greaterThanEqual: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
+) => OperatorNode;
+export const mod: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const equal: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const notEqual: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const lessThan: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const greaterThan: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const lessThanEqual: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const greaterThanEqual: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
 export const and: (
     a: OperatorNodeParameter,
     b: OperatorNodeParameter,
     ...params: OperatorNodeParameter[]
-) => ShaderNodeObject<OperatorNode>;
+) => OperatorNode;
 export const or: (
     a: OperatorNodeParameter,
     b: OperatorNodeParameter,
     ...params: OperatorNodeParameter[]
-) => ShaderNodeObject<OperatorNode>;
-export const not: (value: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const xor: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const bitAnd: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const bitNot: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const bitOr: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const bitXor: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const shiftLeft: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const shiftRight: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-
-export const incrementBefore: (a: OperatorNodeParameter) => ShaderNodeObject<Node>;
-export const decrementBefore: (a: OperatorNodeParameter) => ShaderNodeObject<Node>;
-export const increment: (a: OperatorNodeParameter) => ShaderNodeObject<Node>;
-export const decrement: (a: OperatorNodeParameter) => ShaderNodeObject<Node>;
-
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        add: typeof add;
-        sub: typeof sub;
-        mul: typeof mul;
-        div: typeof div;
-        mod: typeof mod;
-        equal: typeof equal;
-        notEqual: typeof notEqual;
-        lessThan: typeof lessThan;
-        greaterThan: typeof greaterThan;
-        lessThanEqual: typeof lessThanEqual;
-        greaterThanEqual: typeof greaterThanEqual;
-        and: typeof and;
-        or: typeof or;
-        not: typeof not;
-        xor: typeof xor;
-        bitAnd: typeof bitAnd;
-        bitNot: typeof bitNot;
-        bitOr: typeof bitOr;
-        bitXor: typeof bitXor;
-        shiftLeft: typeof shiftLeft;
-        shiftRight: typeof shiftRight;
-        incrementBefore: typeof incrementBefore;
-        decrementBefore: typeof decrement;
-        increment: typeof increment;
-        decrement: typeof decrement;
+) => OperatorNode;
+export const not: (value: OperatorNodeParameter) => OperatorNode;
+export const xor: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const bitAnd: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const bitNot: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const bitOr: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const bitXor: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const shiftLeft: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const shiftRight: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+
+export const incrementBefore: (a: OperatorNodeParameter) => Node;
+export const decrementBefore: (a: OperatorNodeParameter) => Node;
+export const increment: (a: OperatorNodeParameter) => Node;
+export const decrement: (a: OperatorNodeParameter) => Node;
+
+declare module "../Nodes.js" {
+    interface Node {
+        add: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => OperatorNode;
+        addAssign: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => this;
+
+        sub: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => OperatorNode;
+        subAssign: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => this;
+
+        mul: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => OperatorNode;
+        mulAssign: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => this;
+
+        div: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => OperatorNode;
+        divAssign: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => this;
+
+        mod: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        modAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        equal: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        equalAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        notEqual: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        notEqualAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        lessThan: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        lessThanAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        greaterThan: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        greaterThanAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        lessThanEqual: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        lessThanEqualAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        greaterThanEqual: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        greaterThanEqualAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        and: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => OperatorNode;
+        andAssign: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => this;
+
+        or: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => OperatorNode;
+        orAssign: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => this;
+
+        not: () => OperatorNode;
+        notAssign: () => this;
+
+        xor: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        xorAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        bitAnd: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        bitAndAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        bitNot: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        bitNotAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        bitOr: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        bitOrAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        bitXor: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        bitXorAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        shiftLeft: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        shiftLeftAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        shiftRight: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        shiftRightAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        incrementBefore: () => OperatorNode;
+        incrementBeforeAssign: () => this;
+
+        decrementBefore: () => OperatorNode;
+        decrementBeforeAssign: () => this;
+
+        increment: () => OperatorNode;
+        incrementAssign: () => this;
+
+        decrement: () => OperatorNode;
+        decrementAssign: () => this;
     }
 }
 
 /**
  * @deprecated "modInt()" is deprecated. Use "mod( int( ... ) )" instead.
  */
-export const modInt: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
+export const modInt: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
+declare module "../Nodes.js" {
+    interface Nodes {
+        /**
+         * @deprecated "modInt()" is deprecated. Use "mod( int( ... ) )" instead.
+         */
+        modInt: (b: OperatorNodeParameter) => OperatorNode;
         /**
          * @deprecated "modInt()" is deprecated. Use "mod( int( ... ) )" instead.
          */
-        modInt: typeof modInt;
+        modIntAssign: (b: OperatorNodeParameter) => this;
     }
 }