@types/three 0.182.0 → 0.183.1

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

@@ -1,4 +1,4 @@
-import Node from "../core/Node.js";
+import Node, { IntegerType, NumType } from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
 
 export type OperatorNodeOp =
@@ -32,244 +32,507 @@ export default class OperatorNode extends TempNode {
     constructor(op: OperatorNodeOp, ...params: [Node, Node, ...Node[]]);
 }
 
-type OperatorNodeParameter = Node | number;
-
-export const add: (
-    a: OperatorNodeParameter,
-    b: OperatorNodeParameter,
-    ...params: OperatorNodeParameter[]
-) => OperatorNode;
-export const sub: (
-    a: OperatorNodeParameter,
-    b: OperatorNodeParameter,
-    ...params: OperatorNodeParameter[]
-) => OperatorNode;
-export const mul: (
-    a: OperatorNodeParameter,
-    b: OperatorNodeParameter,
-    ...params: OperatorNodeParameter[]
-) => OperatorNode;
-export const div: (
-    a: OperatorNodeParameter,
-    b: OperatorNodeParameter,
-    ...params: OperatorNodeParameter[]
-) => 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[]
-) => OperatorNode;
-export const or: (
-    a: OperatorNodeParameter,
-    b: OperatorNodeParameter,
-    ...params: OperatorNodeParameter[]
-) => 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;
+type Vec2OrLess = Node<"vec2">;
+type Vec3OrLess = Vec2OrLess | Node<"vec3">;
+type Vec4OrLess = Vec3OrLess | Node<"vec4">;
+
+interface NumberToVec {
+    float: "vec";
+    int: "ivec";
+    uint: "uvec";
+}
+
+type NumberToVec2<TNum extends NumType> = `${NumberToVec[TNum]}2`;
+type NumberToVec3<TNum extends NumType> = `${NumberToVec[TNum]}3`;
+type NumberToVec4<TNum extends NumType> = `${NumberToVec[TNum]}4`;
+
+type Number<TNum extends NumType> = AnyNumber; // FIXME Number<TNum> | number
+type Vec2OrLessOrNumber<TNum extends NumType> = Number<TNum> | Node<NumberToVec2<TNum>>;
+type Vec3OrLessOrNumber<TNum extends NumType> = Vec2OrLessOrNumber<TNum> | Node<NumberToVec3<TNum>>;
+type Vec4OrLessOrNumber<TNum extends NumType> = Vec3OrLessOrNumber<TNum> | Node<NumberToVec4<TNum>>;
+
+type AnyNumber = Node<"float"> | Node<"int"> | Node<"uint"> | number;
+
+// add/sub/mul/div
+
+// add/sub/mul/div numbers and/or vecs
+// Every parameter gets converted to the longest type
+// If the parameters are the same length, it gets converted to the first type
+// FIXME We handle the case of converting number types, but not converting between vectors of different number types
+
+interface AddSubMulDivNumberVec<TNum extends NumType> {
+    (a: Number<TNum>, b: AnyNumber, ...params: AnyNumber[]): Node<TNum>;
+    (
+        a: Vec2OrLessOrNumber<TNum>,
+        b: Vec2OrLessOrNumber<TNum>,
+        ...params: Vec2OrLessOrNumber<TNum>[]
+    ): Node<NumberToVec2<TNum>>;
+    (
+        a: Vec3OrLessOrNumber<TNum>,
+        b: Vec3OrLessOrNumber<TNum>,
+        ...params: Vec3OrLessOrNumber<TNum>[]
+    ): Node<NumberToVec3<TNum>>;
+    (
+        a: Vec4OrLessOrNumber<TNum>,
+        b: Vec4OrLessOrNumber<TNum>,
+        ...params: Vec4OrLessOrNumber<TNum>[]
+    ): Node<NumberToVec4<TNum>>;
+}
+
+interface AddSubMulDivNumberVecNumExtensions<TNum extends NumType> {
+    (b: AnyNumber, ...params: AnyNumber[]): Node<TNum>;
+    (b: Vec2OrLessOrNumber<TNum>, ...params: Vec2OrLessOrNumber<TNum>[]): Node<NumberToVec2<TNum>>;
+    (b: Vec3OrLessOrNumber<TNum>, ...params: Vec3OrLessOrNumber<TNum>[]): Node<NumberToVec3<TNum>>;
+    (b: Vec4OrLessOrNumber<TNum>, ...params: Vec4OrLessOrNumber<TNum>[]): Node<NumberToVec4<TNum>>;
+}
+
+interface AddSubMulDivNumberVecNumberAssignExtensions {
+    (
+        b: Vec4OrLessOrNumber<"float"> | Vec4OrLessOrNumber<"int"> | Vec4OrLessOrNumber<"uint">,
+        ...params: (Vec4OrLessOrNumber<"float"> | Vec4OrLessOrNumber<"int"> | Vec4OrLessOrNumber<"uint">)[]
+    ): this;
+}
+
+interface AddSubMulDivNumberVecVec2Extensions<TNum extends NumType> {
+    (b: Vec2OrLessOrNumber<TNum>, ...params: Vec2OrLessOrNumber<TNum>[]): Node<NumberToVec2<TNum>>;
+    (b: Vec3OrLessOrNumber<TNum>, ...params: Vec3OrLessOrNumber<TNum>[]): Node<NumberToVec3<TNum>>;
+    (b: Vec4OrLessOrNumber<TNum>, ...params: Vec4OrLessOrNumber<TNum>[]): Node<NumberToVec4<TNum>>;
+}
+
+interface AddSubMulDivNumberVecVec2AssignExtensions<TNum extends NumType> {
+    (b: Vec4OrLessOrNumber<TNum>, ...params: Vec4OrLessOrNumber<TNum>[]): this;
+}
+
+interface AddSubMulDivNumberVecVec3Extensions<TNum extends NumType> {
+    (b: Vec3OrLessOrNumber<TNum>, ...params: Vec3OrLessOrNumber<TNum>[]): Node<NumberToVec3<TNum>>;
+    (b: Vec4OrLessOrNumber<TNum>, ...params: Vec4OrLessOrNumber<TNum>[]): Node<NumberToVec4<TNum>>;
+}
+
+interface AddSubMulDivNumberVecVec3AssignExtensions<TNum extends NumType> {
+    (b: Vec4OrLessOrNumber<TNum>, ...params: Vec4OrLessOrNumber<TNum>[]): this;
+}
+
+interface AddSubMulDivNumberVecVec4Extensions<TNum extends NumType> {
+    (b: Vec4OrLessOrNumber<TNum>, ...params: Vec4OrLessOrNumber<TNum>[]): Node<NumberToVec4<TNum>>;
+}
+
+interface AddSubMulDivNumberVecVec4AssignExtensions<TNum extends NumType> {
+    (b: Vec4OrLessOrNumber<TNum>, ...params: Vec4OrLessOrNumber<TNum>[]): this;
+}
+
+// add/sub/mul mats
+
+interface AddSubMulMat {
+    (a: Node<"mat2">, b: Node<"mat2">): Node<"mat2">;
+    (a: Node<"mat3">, b: Node<"mat3">): Node<"mat3">;
+    (a: Node<"mat4">, b: Node<"mat4">): Node<"mat4">;
+}
+
+interface AddSubMulMat2Extensions {
+    (b: Node<"mat2">): Node<"mat2">;
+}
+
+interface AddSubMulMat2AssignExtensions {
+    (b: Node<"mat2">): this;
+}
+
+interface AddSubMulMat3Extensions {
+    (b: Node<"mat3">): Node<"mat3">;
+}
+
+interface AddSubMulMat3AssignExtensions {
+    (b: Node<"mat3">): this;
+}
+
+interface AddSubMulMat4Extensions {
+    (b: Node<"mat4">): Node<"mat4">;
+}
+
+interface AddSubMulMat4AssignExtensions {
+    (b: Node<"mat3">): this;
+}
+
+// mut mats and vecs
+// The vec parameter gets converted to matrix length
+
+interface MulMatVec {
+    (a: Node<"mat2">, b: Vec4OrLess): Node<"vec2">;
+    (a: Node<"mat3">, b: Vec4OrLess): Node<"vec3">;
+    (a: Node<"mat4">, b: Vec4OrLess): Node<"vec4">;
+    (a: Vec4OrLess, b: Node<"mat2">): Node<"vec2">;
+    (a: Vec4OrLess, b: Node<"mat3">): Node<"vec3">;
+    (a: Vec4OrLess, b: Node<"mat4">): Node<"vec4">;
+}
+
+interface MulVecMatMat2Extensions {
+    (b: Vec4OrLess): Node<"vec2">;
+}
+
+interface MulVecMatMat3Extensions {
+    (b: Vec4OrLess): Node<"vec3">;
+}
+
+interface MulVecMatMat4Extensions {
+    (b: Vec4OrLess): Node<"vec4">;
+}
+
+interface MulVecMatVecExtensions {
+    (b: Node<"mat2">): Node<"vec2">;
+    (b: Node<"mat3">): Node<"vec3">;
+    (b: Node<"mat4">): Node<"vec4">;
+}
+
+// Exports
+
+interface AddSub
+    extends AddSubMulDivNumberVec<"float">, AddSubMulDivNumberVec<"int">, AddSubMulDivNumberVec<"uint">, AddSubMulMat
+{}
+
+export const add: AddSub;
+export const sub: AddSub;
+
+interface Mul
+    extends
+        AddSubMulDivNumberVec<"float">,
+        AddSubMulDivNumberVec<"int">,
+        AddSubMulDivNumberVec<"uint">,
+        AddSubMulMat,
+        MulMatVec
+{
+}
+
+interface MulVec2Extensions<TNum extends NumType>
+    extends AddSubMulDivNumberVecVec2Extensions<TNum>, MulVecMatVecExtensions
+{
+}
+
+interface MulVec3Extensions<TNum extends NumType>
+    extends AddSubMulDivNumberVecVec3Extensions<TNum>, MulVecMatVecExtensions
+{
+}
+
+interface MulVec4Extensions<TNum extends NumType>
+    extends AddSubMulDivNumberVecVec4Extensions<TNum>, MulVecMatVecExtensions
+{
+}
+
+interface MulMat2Extensions extends AddSubMulMat2Extensions, MulVecMatMat2Extensions {
+}
+
+interface MulMat3Extensions extends AddSubMulMat3Extensions, MulVecMatMat3Extensions {
+}
+
+interface MulMat4Extensions extends AddSubMulMat4Extensions, MulVecMatMat4Extensions {
+}
+
+export const mul: Mul;
+
+interface Div extends AddSubMulDivNumberVec<"float">, AddSubMulDivNumberVec<"int">, AddSubMulDivNumberVec<"uint"> {
+}
+export const div: Div;
+
+declare module "../core/Node.js" {
+    interface FloatExtensions {
+        mul: (b: Node<"color">) => Node<"vec3">;
+    }
+
+    interface NumExtensions<TNum extends NumType> {
+        add: AddSubMulDivNumberVecNumExtensions<TNum>;
+        sub: AddSubMulDivNumberVecNumExtensions<TNum>;
+        mul: AddSubMulDivNumberVecNumExtensions<TNum>;
+        div: AddSubMulDivNumberVecNumExtensions<TNum>;
+
+        addAssign: AddSubMulDivNumberVecNumberAssignExtensions;
+        subAssign: AddSubMulDivNumberVecNumberAssignExtensions;
+        mulAssign: AddSubMulDivNumberVecNumberAssignExtensions;
+        divAssign: AddSubMulDivNumberVecNumberAssignExtensions;
+    }
+
+    interface Vec2Extensions {
+        add: (b: Node<"color">) => Node<"vec3">;
+        mul: (b: Node<"color">) => Node<"vec3">;
+    }
+
+    interface Vec3Extensions {
+        add: (b: Node<"color">) => Node<"vec3">;
+        mul: (b: Node<"color">) => Node<"vec3">;
+    }
+
+    interface Vec4Extensions {
+        add: (b: Node<"color">) => Node<"vec4">;
+        mul: (b: Node<"color">) => Node<"vec4">;
+    }
+
+    interface ColorExtensions {
+        add: (b: Number<"float">) => Node<"vec3">;
+        sub: (b: Number<"float">) => Node<"vec3">;
+        mul: (b: Number<"float">) => Node<"vec3">;
+        div: (b: Number<"float">) => Node<"vec3">;
+    }
+
+    interface NumVec2Extensions<TNum extends NumType> {
+        add: AddSubMulDivNumberVecVec2Extensions<TNum>;
+        sub: AddSubMulDivNumberVecVec2Extensions<TNum>;
+        mul: MulVec2Extensions<TNum>;
+        div: AddSubMulDivNumberVecVec2Extensions<TNum>;
+
+        addAssign: AddSubMulDivNumberVecVec2AssignExtensions<TNum>;
+        subAssign: AddSubMulDivNumberVecVec2AssignExtensions<TNum>;
+        mulAssign: AddSubMulDivNumberVecVec2AssignExtensions<TNum>;
+        divAssign: AddSubMulDivNumberVecVec2AssignExtensions<TNum>;
+    }
+
+    interface NumVec3Extensions<TNum extends NumType> {
+        add: AddSubMulDivNumberVecVec3Extensions<TNum>;
+        sub: AddSubMulDivNumberVecVec3Extensions<TNum>;
+        mul: MulVec3Extensions<TNum>;
+        div: AddSubMulDivNumberVecVec3Extensions<TNum>;
+
+        addAssign: AddSubMulDivNumberVecVec3AssignExtensions<TNum>;
+        subAssign: AddSubMulDivNumberVecVec3AssignExtensions<TNum>;
+        mulAssign: AddSubMulDivNumberVecVec3AssignExtensions<TNum>;
+        divAssign: AddSubMulDivNumberVecVec3AssignExtensions<TNum>;
+    }
+
+    interface NumVec4Extensions<TNum extends NumType> {
+        add: AddSubMulDivNumberVecVec4Extensions<TNum>;
+        sub: AddSubMulDivNumberVecVec4Extensions<TNum>;
+        mul: MulVec4Extensions<TNum>;
+        div: AddSubMulDivNumberVecVec4Extensions<TNum>;
+
+        addAssign: AddSubMulDivNumberVecVec4AssignExtensions<TNum>;
+        subAssign: AddSubMulDivNumberVecVec4AssignExtensions<TNum>;
+        mulAssign: AddSubMulDivNumberVecVec4AssignExtensions<TNum>;
+        divAssign: AddSubMulDivNumberVecVec4AssignExtensions<TNum>;
+    }
+
+    interface Mat2Extensions {
+        add: AddSubMulMat2Extensions;
+        sub: AddSubMulMat2Extensions;
+        mul: MulMat2Extensions;
+
+        addAssign: AddSubMulMat2AssignExtensions;
+        subAssign: AddSubMulMat2AssignExtensions;
+        mulAssign: AddSubMulMat2AssignExtensions;
+    }
+
+    interface Mat3Extensions {
+        add: AddSubMulMat3Extensions;
+        sub: AddSubMulMat3Extensions;
+        mul: MulMat3Extensions;
+
+        addAssign: AddSubMulMat3AssignExtensions;
+        subAssign: AddSubMulMat3AssignExtensions;
+        mulAssign: AddSubMulMat3AssignExtensions;
+    }
+
+    interface Mat4Extensions {
+        add: AddSubMulMat4Extensions;
+        sub: AddSubMulMat4Extensions;
+        mul: MulMat4Extensions;
+
+        addAssign: AddSubMulMat4AssignExtensions;
+        subAssign: AddSubMulMat4AssignExtensions;
+        mulAssign: AddSubMulMat4AssignExtensions;
+    }
+}
+
+// mod
+
+interface Mod {
+    (a: Number<"float">, b: Vec4OrLessOrNumber<"float">): Node<"float">;
+    (a: Node<"vec2">, b: Vec4OrLessOrNumber<"float">): Node<"vec2">;
+    (a: Node<"vec3">, b: Vec4OrLessOrNumber<"float">): Node<"vec3">;
+    (a: Node<"vec4">, b: Vec4OrLessOrNumber<"float">): Node<"vec4">;
+
+    (a: Number<"int">, b: Vec4OrLessOrNumber<"int">): Node<"int">;
+    (a: Node<"ivec2">, b: Vec4OrLessOrNumber<"int">): Node<"ivec2">;
+    (a: Node<"ivec3">, b: Vec4OrLessOrNumber<"int">): Node<"ivec3">;
+    (a: Node<"ivec4">, b: Vec4OrLessOrNumber<"int">): Node<"ivec4">;
+
+    (a: Number<"uint">, b: Vec4OrLessOrNumber<"uint">): Node<"uint">;
+    (a: Node<"uvec2">, b: Vec4OrLessOrNumber<"uint">): Node<"uvec2">;
+    (a: Node<"uvec3">, b: Vec4OrLessOrNumber<"uint">): Node<"uvec3">;
+    (a: Node<"uvec4">, b: Vec4OrLessOrNumber<"uint">): Node<"uvec4">;
+}
+
+export const mod: Mod;
+
+declare module "../core/Node.js" {
+    interface NumExtensions<TNum extends NumType> {
+        mod: (b: Vec4OrLessOrNumber<TNum>) => Node<TNum>;
+        modAssign: (b: Vec4OrLessOrNumber<TNum>) => this;
+    }
+    interface NumVec2Extensions<TNum extends NumType> {
+        mod: (b: Vec4OrLessOrNumber<TNum>) => Node<NumberToVec2<TNum>>;
+        modAssign: (b: Vec4OrLessOrNumber<TNum>) => this;
+    }
+    interface NumVec3Extensions<TNum extends NumType> {
+        mod: (b: Vec4OrLessOrNumber<TNum>) => Node<NumberToVec3<TNum>>;
+        modAssign: (b: Vec4OrLessOrNumber<TNum>) => this;
+    }
+    interface NumVec4Extensions<TNum extends NumType> {
+        mod: (b: Vec4OrLessOrNumber<TNum>) => Node<NumberToVec4<TNum>>;
+        modAssign: (b: Vec4OrLessOrNumber<TNum>) => this;
+    }
+}
+
+// Comparison operators
+
+interface ComparisonOperator {
+    (a: Number<"float">, b: Number<"float">): Node<"bool">;
+    (a: Number<"int"> | Number<"uint">, b: Number<"int"> | Number<"uint">): Node<"bool">;
+}
+export const equal: ComparisonOperator;
+export const notEqual: ComparisonOperator;
+export const lessThan: ComparisonOperator;
+export const greaterThan: ComparisonOperator;
+export const lessThanEqual: ComparisonOperator;
+export const greaterThanEqual: ComparisonOperator;
+
+interface ComparisonOperatorNumExtensions<TNum extends NumType> {
+    (b: Number<TNum>): Node<"bool">;
+}
+
+declare module "../core/Node.js" {
+    interface FloatExtensions {
+        equal: ComparisonOperatorNumExtensions<"float">;
+        notEqual: ComparisonOperatorNumExtensions<"float">;
+        lessThan: ComparisonOperatorNumExtensions<"float">;
+        greaterThan: ComparisonOperatorNumExtensions<"float">;
+        lessThanEqual: ComparisonOperatorNumExtensions<"float">;
+        greaterThanEqual: ComparisonOperatorNumExtensions<"float">;
+    }
+
+    interface IntExtensions {
+        equal: (b: Number<"int"> | Number<"uint">) => Node<"bool">;
+        notEqual: (b: Number<"int"> | Number<"uint">) => Node<"bool">;
+        lessThan: (b: Number<"int"> | Number<"uint">) => Node<"bool">;
+        greaterThan: (b: Number<"int"> | Number<"uint">) => Node<"bool">;
+        lessThanEqual: (b: Number<"int"> | Number<"uint">) => Node<"bool">;
+        greaterThanEqual: (b: Number<"int"> | Number<"uint">) => Node<"bool">;
+    }
+
+    interface UintExtensions {
+        equal: (b: Number<"int"> | Number<"uint">) => Node<"bool">;
+        notEqual: (b: Number<"int"> | Number<"uint">) => Node<"bool">;
+        lessThan: (b: Number<"int"> | Number<"uint">) => Node<"bool">;
+        greaterThan: (b: Number<"int"> | Number<"uint">) => Node<"bool">;
+        lessThanEqual: (b: Number<"int"> | Number<"uint">) => Node<"bool">;
+        greaterThanEqual: (b: Number<"int"> | Number<"uint">) => Node<"bool">;
+    }
+}
+
+// and/or/not/xor
+
+interface AndOr {
+    (a: Node<"bool">, b: Node<"bool">, ...params: Node<"bool">[]): Node<"bool">;
+}
+export const and: AndOr;
+export const or: AndOr;
+
+interface AndOrBoolExtensions {
+    (b: Node<"bool">, ...params: Node<"bool">[]): Node<"bool">;
+}
+
+export const not: (a: Node<"bool">) => Node<"bool">;
+export const xor: (a: Node<"bool">, b: Node<"bool">) => Node<"bool">;
+
+declare module "../core/Node.js" {
+    interface BoolExtensions {
+        and: AndOrBoolExtensions;
+        or: AndOrBoolExtensions;
+        not: () => Node<"bool">;
+        xor: (b: Node<"bool">) => Node<"bool">;
+    }
+}
+
+// bit operators
+
+interface UnaryBitOperator {
+    (a: Number<"int">): Node<"int">;
+    (a: Number<"uint">): Node<"uint">;
+}
+
+interface BinaryBitOperator {
+    (a: Number<"int">, b: Number<"int">): Node<"int">;
+    (a: Number<"uint">, b: Number<"uint">): Node<"uint">;
+}
+
+export const bitAnd: BinaryBitOperator;
+export const bitNot: UnaryBitOperator;
+export const bitOr: BinaryBitOperator;
+export const bitXor: BinaryBitOperator;
+export const shiftLeft: BinaryBitOperator;
+export const shiftRight: BinaryBitOperator;
+
+interface BinaryBitOperatorIntegerExtensions<TInteger extends IntegerType> {
+    (b: Number<TInteger>): Node<TInteger>;
+}
+
+interface BinaryBitOperatorIntegerAssignExtensions<TInteger extends IntegerType> {
+    (b: Number<TInteger>): this;
+}
+
+declare module "../core/Node.js" {
+    interface IntegerExtensions<TInteger extends IntegerType> {
+        bitAnd: BinaryBitOperatorIntegerExtensions<TInteger>;
+        bitNot: () => Node<TInteger>;
+        bitOr: BinaryBitOperatorIntegerExtensions<TInteger>;
+        bitXor: BinaryBitOperatorIntegerExtensions<TInteger>;
+        shiftLeft: BinaryBitOperatorIntegerExtensions<TInteger>;
+        shiftRight: BinaryBitOperatorIntegerExtensions<TInteger>;
+
+        bitAndAssign: BinaryBitOperatorIntegerAssignExtensions<TInteger>;
+        bitNotAssign: () => this;
+        bitOrAssign: BinaryBitOperatorIntegerAssignExtensions<TInteger>;
+        bitXorAssign: BinaryBitOperatorIntegerAssignExtensions<TInteger>;
+        shiftLeftAssign: BinaryBitOperatorIntegerAssignExtensions<TInteger>;
+        shiftRightAssign: BinaryBitOperatorIntegerAssignExtensions<TInteger>;
+    }
+}
+
+// increment/decrement
+
+interface IncrementDecrement {
+    (a: Number<"int">): Node<"int">;
+    (a: Number<"uint">): Node<"uint">;
+}
+
+export const incrementBefore: IncrementDecrement;
+export const decrementBefore: IncrementDecrement;
+export const increment: IncrementDecrement;
+export const decrement: IncrementDecrement;
+
+interface IncrementDecrementIntegerExtensions<TInteger extends IntegerType> {
+    (): Node<TInteger>;
+}
+
+declare module "../core/Node.js" {
+    interface IntegerExtensions<TInteger extends IntegerType> {
+        incrementBefore: IncrementDecrementIntegerExtensions<TInteger>;
+        decrementBefore: IncrementDecrementIntegerExtensions<TInteger>;
+        increment: IncrementDecrementIntegerExtensions<TInteger>;
+        decrement: IncrementDecrementIntegerExtensions<TInteger>;
     }
 }
 
 /**
  * @deprecated "modInt()" is deprecated. Use "mod( int( ... ) )" instead.
  */
-export const modInt: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const modInt: Mod;
 
-declare module "../Nodes.js" {
-    interface Nodes {
+declare module "../core/Node.js" {
+    interface NumExtensions<TNum extends NumType> {
         /**
          * @deprecated "modInt()" is deprecated. Use "mod( int( ... ) )" instead.
          */
-        modInt: (b: OperatorNodeParameter) => OperatorNode;
+        modInt: (b: Number<TNum>) => Node<TNum>;
         /**
          * @deprecated "modInt()" is deprecated. Use "mod( int( ... ) )" instead.
          */
-        modIntAssign: (b: OperatorNodeParameter) => this;
+        modIntAssign: (b: Number<TNum>) => this;
     }
 }
+
+export {};