@types/three 0.181.0 → 0.183.0

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

@@ -1,7 +1,8 @@
+import { Vector2 } from "../../math/Vector2.js";
 import { Vector3 } from "../../math/Vector3.js";
+import { Vector4 } from "../../math/Vector4.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import OperatorNode from "./OperatorNode.js";
 
 export type MathNodeMethod1 =
     | typeof MathNode.RADIANS
@@ -62,7 +63,6 @@ export default class MathNode extends TempNode {
 
     static ALL: "all";
     static ANY: "any";
-    static EQUALS: "equals";
 
     static RADIANS: "radians";
     static DEGREES: "degrees";
@@ -99,6 +99,7 @@ export default class MathNode extends TempNode {
 
     // 2 inputs
 
+    static EQUALS: "equals";
     static MIN: "min";
     static MAX: "max";
     static STEP: "step";
@@ -129,319 +130,654 @@ export default class MathNode extends TempNode {
     constructor(method: MathNodeMethod3, aNode: Node, bNode: Node, cNode: 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 FloatOrNumber = Node<"float"> | number;
+type IntOrNumber = Node<"int"> | number;
+type FloatVector = Node<"vec2"> | Node<"vec3"> | Node<"vec4">;
+type FloatVectorOrNumber = FloatOrNumber | Node<"vec2"> | Node<"vec3"> | Node<"vec4">;
 
-type MathNodeParameter = Node | number;
+type BoolVector = Node<"bvec2"> | Node<"bvec3"> | Node<"bvec4">;
 
-type Unary = (a: MathNodeParameter) => MathNode;
+type Matrix = Node<"mat2"> | Node<"mat3"> | Node<"mat4">;
 
-export const all: Unary;
-export const any: Unary;
+type Vec2OrLessOrFloat = FloatOrNumber | Node<"vec2">;
+type Vec3OrLessOrFloat = Vec2OrLessOrFloat | Node<"vec3">;
+type Vec4OrLessOrFloat = Vec3OrLessOrFloat | Node<"vec4">;
 
-/**
- * @deprecated "equals" is deprecated. Use "equal" inside a vector instead, like: "bvec*( equal( ... ) )"
- */
-export const equals: Unary;
-
-export const radians: Unary;
-export const degrees: Unary;
-export const exp: Unary;
-export const exp2: Unary;
-export const log: Unary;
-export const log2: Unary;
-export const sqrt: Unary;
-export const inverseSqrt: Unary;
-export const floor: Unary;
-export const ceil: Unary;
-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) => MathNode;
-export const abs: Unary;
-export const sign: Unary;
-export const length: Unary;
-export const negate: Unary;
-export const oneMinus: Unary;
-export const dFdx: Unary;
-export const dFdy: Unary;
-export const round: Unary;
-export const reciprocal: Unary;
-export const trunc: Unary;
-export const fwidth: Unary;
-export const transpose: Unary;
-export const determinant: (x: Node) => MathNode;
-export const inverse: (x: Node) => MathNode;
-
-type Binary = (a: MathNodeParameter, b: MathNodeParameter) => MathNode;
-
-export const min: (
-    x: MathNodeParameter,
-    y: MathNodeParameter,
-    ...values: MathNodeParameter[]
-) => MathNode;
-export const max: (
-    x: MathNodeParameter,
-    y: MathNodeParameter,
-    ...values: MathNodeParameter[]
-) => 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) => MathNode;
-export const pow: 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: MathNodeParameter, b: MathNodeParameter, c: MathNodeParameter) => MathNode;
-
-export const mix: Ternary;
-export const clamp: (
-    a: MathNodeParameter,
-    b?: MathNodeParameter,
-    c?: MathNodeParameter,
-) => MathNode;
-export const saturate: Unary;
-export const refract: Ternary;
-export const smoothstep: Ternary;
-export const faceForward: Ternary;
-
-export const rand: (uv: MathNodeParameter) => OperatorNode;
-
-export const mixElement: Ternary;
-export const smoothstepElement: Ternary;
-export const stepElement: Binary;
+export const EPSILON: Node<"float">;
+export const INFINITY: Node<"float">;
+export const PI: Node<"float">;
 
 /**
- * @deprecated
+ * @deprecated Please use the non-deprecated version `TWO_PI`.
  */
-export const atan2: Binary;
-
-// GLSL alias function
-
-export const faceforward: typeof faceForward;
-export const inversesqrt: typeof inverseSqrt;
-
-// Method chaining
-
-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;
+export const PI2: Node<"float">;
 
-        exp2: () => MathNode;
-        exp2Assign: () => this;
+export const TWO_PI: Node<"float">;
 
-        log: () => MathNode;
-        logAssign: () => this;
+export const HALF_PI: Node<"float">;
 
-        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;
+export const all: (x: BoolVector) => Node<"bool">;
+export const any: (x: BoolVector) => Node<"bool">;
+declare module "../core/Node.js" {
+    interface BvecExtensions {
+        all: () => Node<"bool">;
+        any: () => Node<"bool">;
+    }
+}
 
-        tan: () => MathNode;
-        tanAssign: () => this;
+interface UnaryFunction {
+    (x: FloatOrNumber): Node<"float">;
+}
+export const radians: UnaryFunction;
+export const degrees: UnaryFunction;
+export const exp: UnaryFunction;
+export const exp2: UnaryFunction;
+export const log: UnaryFunction;
+export const log2: UnaryFunction;
+export const sqrt: UnaryFunction;
+export const inverseSqrt: UnaryFunction;
+declare module "../core/Node.js" {
+    interface FloatExtensions {
+        radians: () => Node<"float">;
+        degrees: () => Node<"float">;
+        exp: () => Node<"float">;
+        exp2: () => Node<"float">;
+        log: () => Node<"float">;
+        log2: () => Node<"float">;
+        sqrt: () => Node<"float">;
+        inverseSqrt: () => Node<"float">;
+    }
+}
 
-        asin: () => MathNode;
-        asinAssign: () => this;
+interface FloorCeil {
+    (x: FloatOrNumber): Node<"float">;
+    (x: Node<"vec2">): Node<"vec2">;
+    (x: Node<"vec3">): Node<"vec3">;
+    (x: Node<"vec4">): Node<"vec4">;
+}
+export const floor: FloorCeil;
+export const ceil: FloorCeil;
+declare module "../core/Node.js" {
+    interface FloatExtensions {
+        floor: () => Node<"float">;
+        ceil: () => Node<"float">;
+    }
+    interface FloatVecExtensions<TVec extends FloatVecType> {
+        floor: () => Node<TVec>;
+        ceil: () => Node<TVec>;
+    }
+}
 
-        acos: () => MathNode;
-        acosAssign: () => this;
+interface Normalize {
+    (x: Node<"vec2"> | Vector2): Node<"vec2">;
+    (x: Node<"vec3"> | Vector3): Node<"vec3">;
+    (x: Node<"vec4"> | Vector4): Node<"vec4">;
+}
+export const normalize: Normalize;
+declare module "../core/Node.js" {
+    interface FloatVecExtensions<TVec extends FloatVecType> {
+        normalize: () => Node<TVec>;
+    }
+}
 
-        atan: (b?: MathNodeParameter) => MathNode;
-        atanAssign: (b?: MathNodeParameter) => this;
+interface Fract {
+    (x: FloatOrNumber): Node<"float">;
+    (x: Node<"vec2">): Node<"vec2">;
+    (x: Node<"vec3">): Node<"vec3">;
+    (x: Node<"vec4">): Node<"vec4">;
+}
+export const fract: Fract;
+declare module "../core/Node.js" {
+    interface FloatExtensions {
+        fract: () => Node<"float">;
+    }
+    interface FloatVecExtensions<TVec extends FloatVecType> {
+        fract: () => Node<TVec>;
+    }
+}
 
-        abs: () => MathNode;
-        absAssign: () => this;
+export const sin: (x: FloatOrNumber) => Node<"float">;
+export const cos: (x: FloatOrNumber) => Node<"float">;
+export const tan: (x: FloatOrNumber) => Node<"float">;
+export const asin: (x: FloatOrNumber) => Node<"float">;
+export const acos: (x: FloatOrNumber) => Node<"float">;
+export const atan: (y: FloatOrNumber, x?: FloatOrNumber) => Node<"float">;
+declare module "../core/Node.js" {
+    interface FloatExtensions {
+        sin: () => Node<"float">;
+        cos: () => Node<"float">;
+        tan: () => Node<"float">;
+        asin: () => Node<"float">;
+        acos: () => Node<"float">;
+        atan: (x?: FloatOrNumber) => Node<"float">;
+    }
+}
 
-        sign: () => MathNode;
-        signAssign: () => this;
+interface Abs {
+    (x: FloatOrNumber): Node<"float">;
+    (x: Node<"vec2">): Node<"vec2">;
+    (x: Node<"vec3">): Node<"vec3">;
+    (x: Node<"vec4">): Node<"vec4">;
+    (x: IntOrNumber): Node<"int">;
+}
+export const abs: Abs;
+declare module "../core/Node.js" {
+    interface FloatExtensions {
+        abs: () => Node<"float">;
+    }
+    interface IntExtensions {
+        abs: () => Node<"int">;
+    }
+    interface FloatVecExtensions<TVec extends FloatVecType> {
+        abs: () => Node<TVec>;
+    }
+}
 
-        length: () => MathNode;
-        lengthAssign: () => this;
+interface Sign {
+    (x: FloatOrNumber): Node<"float">;
+    (x: Node<"vec2">): Node<"vec2">;
+    (x: Node<"vec3">): Node<"vec3">;
+    (x: Node<"vec4">): Node<"vec4">;
+}
+export const sign: Sign;
+declare module "../core/Node.js" {
+    interface FloatExtensions {
+        sign: () => Node<"float">;
+    }
+    interface FloatVecExtensions<TVec extends FloatVecType> {
+        sign: () => Node<TVec>;
+    }
+}
 
-        lengthSq: () => MathNode;
-        lengthSqAssign: () => this;
+export const length: (x: FloatVector | Node) => Node<"float">;
+declare module "../core/Node.js" {
+    interface FloatVecExtensions<TVec extends FloatVecType> {
+        length: () => Node<"float">;
+    }
+}
 
-        negate: () => MathNode;
-        negateAssign: () => this;
+interface Negate {
+    (x: FloatOrNumber): Node<"float">;
+    (x: Node<"vec2">): Node<"vec2">;
+    (x: Node<"vec3">): Node<"vec3">;
+    (x: Node<"vec4">): Node<"vec4">;
+}
+export const negate: Negate;
+declare module "../core/Node.js" {
+    interface FloatExtensions {
+        negate: () => Node<"float">;
+    }
+    interface FloatVecExtensions<TVec extends FloatVecType> {
+        negate: () => Node<TVec>;
+    }
+}
 
-        oneMinus: () => MathNode;
-        oneMinusAssign: () => this;
+interface OneMinus {
+    (x: FloatOrNumber): Node<"float">;
+    (x: Node<"vec2">): Node<"vec2">;
+    (x: Node<"vec3">): Node<"vec3">;
+    (x: Node<"vec4">): Node<"vec4">;
+}
+export const oneMinus: OneMinus;
+declare module "../core/Node.js" {
+    interface FloatExtensions {
+        oneMinus: () => Node<"float">;
+    }
+    interface FloatVecExtensions<TVec extends FloatVecType> {
+        oneMinus: () => Node<TVec>;
+    }
+}
 
-        dFdx: () => MathNode;
-        dFdxAssign: () => this;
+interface Derivative {
+    (x: Node<"vec2">): Node<"vec2">;
+    (x: Node<"vec3">): Node<"vec3">;
+    (x: Node<"vec4">): Node<"vec4">;
+}
+export const dFdx: Derivative;
+export const dFdy: Derivative;
+declare module "../core/Node.js" {
+    interface FloatVecExtensions<TVec extends FloatVecType> {
+        dFdx: () => Node<TVec>;
+        dFdy: () => Node<TVec>;
+    }
+}
 
-        dFdy: () => MathNode;
-        dFdyAssign: () => this;
+export const round: (x: FloatOrNumber) => Node<"float">;
+export const reciprocal: (x: FloatOrNumber) => Node<"float">;
+export const trunc: (x: FloatOrNumber) => Node<"float">;
+declare module "../core/Node.js" {
+    interface FloatExtensions {
+        round: () => Node<"float">;
+        reciprocal: () => Node<"float">;
+        trunc: () => Node<"float">;
+    }
+}
 
-        round: () => MathNode;
-        roundAssign: () => this;
+interface Fwidth {
+    (x: FloatOrNumber): Node<"float">;
+    (x: Node<"vec2">): Node<"vec2">;
+    (x: Node<"vec3">): Node<"vec3">;
+    (x: Node<"vec4">): Node<"vec4">;
+}
+export const fwidth: Fwidth;
+declare module "../core/Node.js" {
+    interface FloatExtensions {
+        fwidth: () => Node<"float">;
+    }
+    interface FloatVecExtensions<TVec extends FloatVecType> {
+        fwidth: () => Node<TVec>;
+    }
+}
 
-        reciprocal: () => MathNode;
-        reciprocalAssign: () => this;
+interface Transpose {
+    (x: Node<"mat2">): Node<"mat2">;
+    (x: Node<"mat3">): Node<"mat3">;
+    (x: Node<"mat4">): Node<"mat4">;
+}
+export const transpose: Transpose;
+declare module "../core/Node.js" {
+    interface MatExtensions<TMat extends MatType> {
+        transpose: () => Node<TMat>;
+    }
+}
 
-        trunc: () => MathNode;
-        truncAssign: () => this;
+export const determinant: (x: Matrix) => Node<"float">;
+declare module "../core/Node.js" {
+    interface MatExtensions<TMat extends MatType> {
+        determinant: () => Node<"float">;
+    }
+}
 
-        fwidth: () => MathNode;
-        fwidthAssign: () => this;
+interface Inverse {
+    (x: Node<"mat2">): Node<"mat2">;
+    (x: Node<"mat3">): Node<"mat3">;
+    (x: Node<"mat4">): Node<"mat4">;
+}
+export const inverse: Inverse;
+declare module "../core/Node.js" {
+    interface MatExtensions<TMat extends MatType> {
+        inverse: () => Node<TMat>;
+    }
+}
 
-        /**
-         * @deprecated
-         */
-        atan2: (b: MathNodeParameter) => MathNode;
-        /**
-         * @deprecated
-         */
-        atan2Assign: (b: MathNodeParameter) => this;
+interface MinMax {
+    (x: FloatOrNumber, y: FloatOrNumber, ...params: FloatOrNumber[]): Node<"float">;
+    (x: Vec2OrLessOrFloat, y: Vec2OrLessOrFloat, ...params: Vec2OrLessOrFloat[]): Node<"vec2">;
+    (x: Vec3OrLessOrFloat, y: Vec3OrLessOrFloat, ...params: Vec3OrLessOrFloat[]): Node<"vec3">;
+    (x: Vec4OrLessOrFloat, y: Vec4OrLessOrFloat, ...params: Vec4OrLessOrFloat[]): Node<"vec4">;
+}
+export const min: MinMax;
+export const max: MinMax;
+interface MinMaxFloatExtension {
+    (y: FloatOrNumber, ...params: FloatOrNumber[]): Node<"float">;
+    (y: Vec2OrLessOrFloat, ...params: Vec2OrLessOrFloat[]): Node<"vec2">;
+    (y: Vec3OrLessOrFloat, ...params: Vec3OrLessOrFloat[]): Node<"vec3">;
+    (y: Vec4OrLessOrFloat, ...params: Vec4OrLessOrFloat[]): Node<"vec4">;
+}
+interface MinMaxVec2Extension {
+    (y: Vec2OrLessOrFloat, ...params: Vec2OrLessOrFloat[]): Node<"vec2">;
+    (y: Vec3OrLessOrFloat, ...params: Vec3OrLessOrFloat[]): Node<"vec3">;
+    (y: Vec4OrLessOrFloat, ...params: Vec4OrLessOrFloat[]): Node<"vec4">;
+}
+interface MinMaxVec3Extension {
+    (y: Vec3OrLessOrFloat, ...params: Vec3OrLessOrFloat[]): Node<"vec3">;
+    (y: Vec4OrLessOrFloat, ...params: Vec4OrLessOrFloat[]): Node<"vec4">;
+}
+interface MinMaxVec4Extension {
+    (y: Vec4OrLessOrFloat, ...params: Vec4OrLessOrFloat[]): Node<"vec4">;
+}
+declare module "../core/Node.js" {
+    interface FloatExtensions {
+        min: MinMaxFloatExtension;
+        max: MinMaxFloatExtension;
+    }
+    interface Vec2Extensions {
+        min: MinMaxVec2Extension;
+        max: MinMaxVec2Extension;
+    }
+    interface Vec3Extensions {
+        min: MinMaxVec3Extension;
+        max: MinMaxVec3Extension;
+    }
+    interface Vec4Extensions {
+        min: MinMaxVec4Extension;
+        max: MinMaxVec4Extension;
+    }
+}
 
-        min: (
-            y: MathNodeParameter,
-            ...values: MathNodeParameter[]
-        ) => MathNode;
-        minAssign: (
-            y: MathNodeParameter,
-            ...values: MathNodeParameter[]
-        ) => this;
+export const step: (x: FloatOrNumber, y: FloatOrNumber) => Node<"float">;
 
-        max: (
-            y: MathNodeParameter,
-            ...values: MathNodeParameter[]
-        ) => MathNode;
-        maxAssign: (
-            y: MathNodeParameter,
-            ...values: MathNodeParameter[]
-        ) => this;
+interface Reflect {
+    (I: Vec2OrLessOrFloat, N: Vec2OrLessOrFloat): Node<"vec2">;
+    (I: Vec3OrLessOrFloat, N: Vec3OrLessOrFloat): Node<"vec3">;
+    (I: Vec4OrLessOrFloat, N: Vec4OrLessOrFloat): Node<"vec4">;
+}
+export const reflect: Reflect;
+interface ReflectVec2Extension {
+    (N: Vec2OrLessOrFloat): Node<"vec2">;
+    (N: Vec3OrLessOrFloat): Node<"vec3">;
+    (N: Vec4OrLessOrFloat): Node<"vec4">;
+}
+interface ReflectVec3Extension {
+    (N: Vec3OrLessOrFloat): Node<"vec3">;
+    (N: Vec4OrLessOrFloat): Node<"vec4">;
+}
+interface ReflectVec4Extension {
+    (N: Vec4OrLessOrFloat): Node<"vec4">;
+}
+declare module "../core/Node.js" {
+    interface Vec2Extensions {
+        reflect: ReflectVec2Extension;
+    }
+    interface Vec3Extensions {
+        reflect: ReflectVec3Extension;
+    }
+    interface Vec4Extensions {
+        reflect: ReflectVec4Extension;
+    }
+}
 
-        step: (b: MathNodeParameter) => MathNode;
-        stepAssign: (b: MathNodeParameter) => this;
+export const distance: (x: FloatVectorOrNumber, y: FloatVectorOrNumber) => Node<"float">;
+declare module "../core/Node.js" {
+    interface FloatExtensions {
+        distance: (y: FloatVectorOrNumber) => Node<"float">;
+    }
+    interface FloatVecExtensions<TVec extends FloatVecType> {
+        distance: (y: FloatVectorOrNumber) => Node<"float">;
+    }
+}
 
-        reflect: (b: MathNodeParameter) => MathNode;
-        reflectAssign: (b: MathNodeParameter) => this;
+interface Difference {
+    (x: FloatOrNumber, y: FloatOrNumber): Node<"float">;
+    (x: Vec2OrLessOrFloat, y: Vec2OrLessOrFloat): Node<"vec2">;
+    (x: Vec3OrLessOrFloat, y: Vec3OrLessOrFloat): Node<"vec3">;
+    (x: Vec4OrLessOrFloat, y: Vec4OrLessOrFloat): Node<"vec4">;
+}
+export const difference: Difference;
+interface DifferenceFloatExtension {
+    (y: FloatOrNumber): Node<"float">;
+    (y: Vec2OrLessOrFloat): Node<"vec2">;
+    (y: Vec3OrLessOrFloat): Node<"vec3">;
+    (y: Vec4OrLessOrFloat): Node<"vec4">;
+}
+interface DifferenceVec2Extension {
+    (y: Vec2OrLessOrFloat): Node<"vec2">;
+    (y: Vec3OrLessOrFloat): Node<"vec3">;
+    (y: Vec4OrLessOrFloat): Node<"vec4">;
+}
+interface DifferenceVec3Extension {
+    (y: Vec3OrLessOrFloat): Node<"vec3">;
+    (y: Vec4OrLessOrFloat): Node<"vec4">;
+}
+interface DifferenceVec4Extension {
+    (y: Vec4OrLessOrFloat): Node<"vec4">;
+}
+declare module "../core/Node.js" {
+    interface FloatExtensions {
+        difference: DifferenceFloatExtension;
+    }
+    interface Vec2Extensions {
+        difference: DifferenceVec2Extension;
+    }
+    interface Vec3Extensions {
+        difference: DifferenceVec3Extension;
+    }
+    interface Vec4Extensions {
+        difference: DifferenceVec4Extension;
+    }
+}
 
-        distance: (b: MathNodeParameter) => MathNode;
-        distanceAssign: (b: MathNodeParameter) => this;
+export const dot: (x: FloatVector, y: FloatVector) => Node<"float">;
+declare module "../core/Node.js" {
+    interface FloatVecExtensions<TVec extends FloatVecType> {
+        dot: (y: FloatVector) => Node<"float">;
+    }
+}
 
-        dot: (b: MathNodeParameter) => MathNode;
-        dotAssign: (b: MathNodeParameter) => this;
+export const cross: (x: Node<"vec3">, y: Node<"vec3">) => Node<"vec3">;
+declare module "../core/Node.js" {
+    interface Vec3Extensions {
+        cross: (y: Node<"vec3">) => Node<"vec3">;
+    }
+}
 
-        cross: (y: Node) => MathNode;
-        crossAssign: (y: Node) => this;
+interface Pow {
+    (x: FloatOrNumber, y: FloatOrNumber): Node<"float">;
+    (x: Node<"vec2">, y: Node<"vec2">): Node<"vec2">;
+    (x: Node<"vec3">, y: Node<"vec3">): Node<"vec3">;
+    (x: Node<"vec4">, y: Node<"vec4">): Node<"vec4">;
+}
+export const pow: (x: FloatOrNumber, y: FloatOrNumber) => Node<"float">;
+declare module "../core/Node.js" {
+    interface FloatExtensions {
+        pow: (y: FloatOrNumber) => Node<"float">;
+    }
+    interface FloatVecExtensions<TVec extends FloatVecType> {
+        pow: (y: Node<TVec>) => Node<TVec>;
+    }
+}
 
-        pow: (b: MathNodeParameter) => MathNode;
-        powAssign: (b: MathNodeParameter) => this;
+interface PowConstant {
+    (x: FloatOrNumber): Node<"float">;
+    (x: Node<"vec2">): Node<"vec2">;
+    (x: Node<"vec3">): Node<"vec3">;
+    (x: Node<"vec4">): Node<"vec4">;
+}
+export const pow2: PowConstant;
+export const pow3: PowConstant;
+export const pow4: PowConstant;
+declare module "../core/Node.js" {
+    interface FloatExtensions {
+        pow2: () => Node<"float">;
+        pow3: () => Node<"float">;
+        pow4: () => Node<"float">;
+    }
+    interface FloatVecExtensions<TVec extends FloatVecType> {
+        pow2: () => Node<TVec>;
+        pow3: () => Node<TVec>;
+        pow4: () => Node<TVec>;
+    }
+}
 
-        pow2: () => MathNode;
-        pow2Assign: () => this;
+export const transformDirection: (direction: Node<"vec3">, matrix: Node<"mat3"> | Node<"mat4">) => Node<"vec3">;
+declare module "../core/Node.js" {
+    interface Vec3Extensions {
+        transformDirection: (matrix: Node<"mat3"> | Node<"mat4">) => Node<"vec3">;
+    }
+}
 
-        pow3: () => MathNode;
-        pow3Assign: () => this;
+export const cbrt: (a: FloatOrNumber) => Node<"float">;
+declare module "../core/Node.js" {
+    interface FloatExtensions {
+        cbrt: () => Node<"float">;
+    }
+}
 
-        pow4: () => MathNode;
-        pow4Assign: () => this;
+export const lengthSq: (a: FloatVector) => Node<"float">;
+declare module "../core/Node.js" {
+    interface FloatVecExtensions<TVec extends FloatVecType> {
+        lengthSq: () => Node<"float">;
+    }
+}
 
-        transformDirection: (b: MathNodeParameter) => MathNode;
-        transformDirectionAssign: (b: MathNodeParameter) => this;
+interface Mix {
+    (a: FloatOrNumber, b: FloatOrNumber, t: FloatOrNumber): Node<"float">;
+    (a: Vec2OrLessOrFloat, b: Vec2OrLessOrFloat, t: FloatOrNumber): Node<"vec2">;
+    (a: Vec3OrLessOrFloat | Node<"color">, b: Vec3OrLessOrFloat | Node<"color">, t: FloatOrNumber): Node<"vec3">;
+    (a: Vec4OrLessOrFloat, b: Vec4OrLessOrFloat, t: FloatOrNumber): Node<"vec4">;
+}
+export const mix: Mix;
 
-        mix: (b: MathNodeParameter, c: MathNodeParameter) => MathNode;
-        mixAssign: (b: MathNodeParameter, c: MathNodeParameter) => this;
+interface Clamp {
+    (value: FloatOrNumber, low?: FloatOrNumber, high?: FloatOrNumber): Node<"float">;
+    (value: Vec2OrLessOrFloat, low?: Vec2OrLessOrFloat, high?: Vec2OrLessOrFloat): Node<"vec2">;
+    (value: Vec3OrLessOrFloat, low?: Vec3OrLessOrFloat, high?: Vec3OrLessOrFloat): Node<"vec3">;
+    (value: Vec4OrLessOrFloat, low?: Vec4OrLessOrFloat, high?: Vec4OrLessOrFloat): Node<"vec4">;
+}
+export const clamp: Clamp;
+interface ClampFloatExtension {
+    (low?: FloatOrNumber, high?: FloatOrNumber): Node<"float">;
+    (low?: Vec2OrLessOrFloat, high?: Vec2OrLessOrFloat): Node<"vec2">;
+    (low?: Vec3OrLessOrFloat, high?: Vec3OrLessOrFloat): Node<"vec3">;
+    (low?: Vec4OrLessOrFloat, high?: Vec4OrLessOrFloat): Node<"vec4">;
+}
+interface ClampVec2Extension {
+    (low?: Vec2OrLessOrFloat, high?: Vec2OrLessOrFloat): Node<"vec2">;
+    (low?: Vec3OrLessOrFloat, high?: Vec3OrLessOrFloat): Node<"vec3">;
+    (low?: Vec4OrLessOrFloat, high?: Vec4OrLessOrFloat): Node<"vec4">;
+}
+interface ClampVec3Extension {
+    (low?: Vec3OrLessOrFloat, high?: Vec3OrLessOrFloat): Node<"vec3">;
+    (low?: Vec4OrLessOrFloat, high?: Vec4OrLessOrFloat): Node<"vec4">;
+}
+interface ClampVec4Extension {
+    (low?: Vec4OrLessOrFloat, high?: Vec4OrLessOrFloat): Node<"vec4">;
+}
+declare module "../core/Node.js" {
+    interface FloatExtensions {
+        clamp: ClampFloatExtension;
+    }
+    interface Vec2Extensions {
+        clamp: ClampVec2Extension;
+    }
+    interface Vec3Extensions {
+        clamp: ClampVec3Extension;
+    }
+    interface Vec4Extensions {
+        clamp: ClampVec4Extension;
+    }
+}
 
-        clamp: (b?: MathNodeParameter, c?: MathNodeParameter) => MathNode;
-        clampAssign: (b?: MathNodeParameter, c?: MathNodeParameter) => this;
+interface Saturate {
+    (value: FloatOrNumber): Node<"float">;
+    (value: Node<"vec2">): Node<"vec2">;
+    (value: Node<"vec3">): Node<"vec3">;
+    (value: Node<"vec4">): Node<"vec4">;
+}
+export const saturate: Saturate;
+declare module "../core/Node.js" {
+    interface FloatExtensions {
+        saturate: () => Node<"float">;
+    }
+    interface FloatVecExtensions<TVec extends FloatVecType> {
+        saturate: () => Node<TVec>;
+    }
+}
 
-        refract: (b: MathNodeParameter, c: MathNodeParameter) => MathNode;
-        refractAssign: (b: MathNodeParameter, c: MathNodeParameter) => this;
+interface Refract {
+    (I: Vec2OrLessOrFloat, N: Vec2OrLessOrFloat, ratio: FloatOrNumber): Node<"vec2">;
+    (I: Vec3OrLessOrFloat, N: Vec3OrLessOrFloat, ratio: FloatOrNumber): Node<"vec3">;
+    (I: Vec4OrLessOrFloat, N: Vec4OrLessOrFloat, ratio: FloatOrNumber): Node<"vec4">;
+}
+export const refract: Refract;
+interface RefractVec2Extension {
+    (N: Vec2OrLessOrFloat, ratio: FloatOrNumber): Node<"vec2">;
+    (N: Vec3OrLessOrFloat, ratio: FloatOrNumber): Node<"vec3">;
+    (N: Vec4OrLessOrFloat, ratio: FloatOrNumber): Node<"vec4">;
+}
+interface RefractVec3Extension {
+    (N: Vec3OrLessOrFloat, ratio: FloatOrNumber): Node<"vec3">;
+    (N: Vec4OrLessOrFloat, ratio: FloatOrNumber): Node<"vec4">;
+}
+interface RefractVec4Extension {
+    (N: Vec4OrLessOrFloat, ratio: FloatOrNumber): Node<"vec4">;
+}
+declare module "../core/Node.js" {
+    interface Vec2Extensions {
+        refract: RefractVec2Extension;
+    }
+    interface Vec3Extensions {
+        refract: RefractVec3Extension;
+    }
+    interface Vec4Extensions {
+        refract: RefractVec4Extension;
+    }
+}
 
-        smoothstep: (b: MathNodeParameter, c: MathNodeParameter) => MathNode;
-        smoothstepAssign: (b: MathNodeParameter, c: MathNodeParameter) => this;
+interface Smoothstep {
+    (low: FloatOrNumber, high: FloatOrNumber, x: FloatOrNumber): Node<"float">;
+}
+export const smoothstep: Smoothstep;
 
-        faceForward: (b: MathNodeParameter, c: MathNodeParameter) => MathNode;
-        faceForwardAssign: (b: MathNodeParameter, c: MathNodeParameter) => this;
+interface FaceForward {
+    (N: Vec2OrLessOrFloat, I: Vec2OrLessOrFloat, Nref: Vec2OrLessOrFloat): Node<"vec2">;
+    (N: Vec3OrLessOrFloat, I: Vec3OrLessOrFloat, Nref: Vec3OrLessOrFloat): Node<"vec3">;
+    (N: Vec4OrLessOrFloat, I: Vec4OrLessOrFloat, Nref: Vec4OrLessOrFloat): Node<"vec4">;
+}
+export const faceForward: FaceForward;
+interface FaceForwardVec2Extension {
+    (I: Vec2OrLessOrFloat, Nref: Vec2OrLessOrFloat): Node<"vec2">;
+    (I: Vec3OrLessOrFloat, Nref: Vec3OrLessOrFloat): Node<"vec3">;
+    (I: Vec4OrLessOrFloat, Nref: Vec4OrLessOrFloat): Node<"vec4">;
+}
+interface FaceForwardVec3Extension {
+    (N: Vec3OrLessOrFloat, ratio: Vec3OrLessOrFloat): Node<"vec3">;
+    (N: Vec4OrLessOrFloat, ratio: Vec4OrLessOrFloat): Node<"vec4">;
+}
+interface FaceForwardVec4Extension {
+    (N: Vec4OrLessOrFloat, ratio: Vec4OrLessOrFloat): Node<"vec4">;
+}
+declare module "../core/Node.js" {
+    interface Vec2Extensions {
+        faceForward: FaceForwardVec2Extension;
+    }
+    interface Vec3Extensions {
+        faceForward: FaceForwardVec3Extension;
+    }
+    interface Vec4Extensions {
+        faceForward: FaceForwardVec4Extension;
+    }
+}
 
-        difference: (b: MathNodeParameter) => MathNode;
-        differenceAssign: (b: MathNodeParameter) => this;
+export const rand: (uv: Node<"vec2">) => Node<"float">;
+declare module "../core/Node.js" {
+    interface Vec2Extensions {
+        rand: () => Node<"float">;
+    }
+}
 
-        saturate: () => MathNode;
-        saturateAssign: () => this;
+interface MixElement {
+    (t: FloatOrNumber, e1: FloatOrNumber, e2: FloatOrNumber): Node<"float">;
+    (t: FloatOrNumber, e1: Vec2OrLessOrFloat, e2: Vec2OrLessOrFloat): Node<"vec2">;
+    (t: FloatOrNumber, e1: Vec3OrLessOrFloat | Node<"color">, e2: Vec3OrLessOrFloat | Node<"color">): Node<"vec3">;
+    (t: FloatOrNumber, e1: Vec4OrLessOrFloat, e2: Vec4OrLessOrFloat): Node<"vec4">;
+}
+export const mixElement: MixElement;
+interface MixExtension {
+    (e1: FloatOrNumber, e2: FloatOrNumber): Node<"float">;
+    (e1: Vec2OrLessOrFloat, e2: Vec2OrLessOrFloat): Node<"vec2">;
+    (e1: Vec3OrLessOrFloat | Node<"color">, e2: Vec3OrLessOrFloat | Node<"color">): Node<"vec3">;
+    (e1: Vec4OrLessOrFloat | Node<"color">, e2: Vec4OrLessOrFloat | Node<"color">): Node<"vec4">;
+}
+declare module "../core/Node.js" {
+    interface FloatExtensions {
+        mix: MixExtension;
+    }
+}
 
-        cbrt: () => MathNode;
-        cbrtAssign: () => this;
+interface SmoothstepElement {
+    (x: FloatOrNumber, low: FloatOrNumber, high: FloatOrNumber): Node<"float">;
+}
+export const smoothstepElement: SmoothstepElement;
+interface SmoothstepExtension {
+    (low: FloatOrNumber, high: FloatOrNumber): Node<"float">;
+}
+declare module "../core/Node.js" {
+    interface FloatExtensions {
+        smoothstep: SmoothstepExtension;
+    }
+}
 
-        transpose: () => MathNode;
-        transposeAssign: () => this;
+export const stepElement: (x: FloatOrNumber, edge: FloatOrNumber) => Node<"float">;
+declare module "../core/Node.js" {
+    interface FloatExtensions {
+        step: (edge: FloatOrNumber) => Node<"float">;
+    }
+}
 
-        determinant: () => MathNode;
-        determinantAssign: () => this;
+// GLSL alias function
 
-        inverse: () => MathNode;
-        inverseAssign: () => this;
+export const faceforward: typeof faceForward;
+export const inversesqrt: typeof inverseSqrt;
 
-        rand: () => OperatorNode;
-        randAssign: () => this;
-    }
-}
+export {};