@types/three 0.180.0 → 0.181.0

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

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type AtomicMethod =
     | typeof AtomicFunctionNode.ATOMIC_LOAD
@@ -35,48 +34,48 @@ export const atomicFunc: (
     method: AtomicMethod,
     pointerNode: Node,
     valueNode: Node,
-) => ShaderNodeObject<AtomicFunctionNode>;
+) => AtomicFunctionNode;
 
 export const atomicLoad: (
     pointerNode: Node,
-) => ShaderNodeObject<AtomicFunctionNode>;
+) => AtomicFunctionNode;
 
 export const atomicStore: (
     pointerNode: Node,
     valueNode: Node | number,
-) => ShaderNodeObject<AtomicFunctionNode>;
+) => AtomicFunctionNode;
 
 export const atomicAdd: (
     pointerNode: Node,
     valueNode: Node | number,
-) => ShaderNodeObject<AtomicFunctionNode>;
+) => AtomicFunctionNode;
 
 export const atomicSub: (
     pointerNode: Node,
     valueNode: Node | number,
-) => ShaderNodeObject<AtomicFunctionNode>;
+) => AtomicFunctionNode;
 
 export const atomicMax: (
     pointerNode: Node,
     valueNode: Node,
-) => ShaderNodeObject<AtomicFunctionNode>;
+) => AtomicFunctionNode;
 
 export const atomicMin: (
     pointerNode: Node,
     valueNode: Node,
-) => ShaderNodeObject<AtomicFunctionNode>;
+) => AtomicFunctionNode;
 
 export const atomicAnd: (
     pointerNode: Node,
     valueNode: Node,
-) => ShaderNodeObject<AtomicFunctionNode>;
+) => AtomicFunctionNode;
 
 export const atomicOr: (
     pointerNode: Node,
     valueNode: Node,
-) => ShaderNodeObject<AtomicFunctionNode>;
+) => AtomicFunctionNode;
 
 export const atomicXor: (
     pointerNode: Node,
     valueNode: Node,
-) => ShaderNodeObject<AtomicFunctionNode>;
+) => AtomicFunctionNode;

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

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class BarrierNode extends Node {
     scope: string;
@@ -7,6 +6,6 @@ declare class BarrierNode extends Node {
     constructor(scope: string);
 }
 
-export const workgroupBarrier: () => ShaderNodeObject<Node>;
-export const storageBarrier: () => ShaderNodeObject<Node>;
-export const textureBarrier: () => ShaderNodeObject<Node>;
+export const workgroupBarrier: () => Node;
+export const storageBarrier: () => Node;
+export const textureBarrier: () => Node;

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

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class ComputeBuiltinNode extends Node {
     constructor(builtinName: string, nodeType: string);
@@ -7,8 +6,8 @@ declare class ComputeBuiltinNode extends Node {
 
 export default ComputeBuiltinNode;
 
-export const numWorkgroups: ShaderNodeObject<ComputeBuiltinNode>;
-export const workgroupId: ShaderNodeObject<ComputeBuiltinNode>;
-export const globalId: ShaderNodeObject<ComputeBuiltinNode>;
-export const localId: ShaderNodeObject<ComputeBuiltinNode>;
-export const subgroupSize: ShaderNodeObject<ComputeBuiltinNode>;
+export const numWorkgroups: ComputeBuiltinNode;
+export const workgroupId: ComputeBuiltinNode;
+export const globalId: ComputeBuiltinNode;
+export const localId: ComputeBuiltinNode;
+export const subgroupSize: ComputeBuiltinNode;

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

@@ -1,43 +1,51 @@
 import Renderer from "../../renderers/common/Renderer.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class ComputeNode extends Node {
     readonly isComputeNode: true;
 
     computeNode: Node;
     workgroupSize: number[];
-    count: number | null;
+    count: number | number[] | null;
     name: string;
 
     onInitFunction: ((args: { renderer: Renderer }) => void) | null;
 
     constructor(computeNode: Node, workgroupSize: number[]);
 
-    setCount(count: number): this;
-    getCount(): number | null;
+    setCount(count: number | number[]): this;
+    getCount(): number | number[] | null;
 
-    setName(name: string): this;
+    setName: (name: string) => this;
 
     /**
      * @deprecated "label()" has been deprecated. Use "setName()" instead.
      */
-    label(name: string): this;
+    label: (name: string) => this;
 
     onInit(callback: ((args: { renderer: Renderer }) => void) | null): void;
 }
 
-export const computeKernel: (node: Node, workgroupSize?: number[]) => ShaderNodeObject<ComputeNode>;
+export const computeKernel: (node: Node, workgroupSize?: number[]) => ComputeNode;
 
 export const compute: (
     node: Node,
     count: number,
     workgroupSize?: number[],
-) => ShaderNodeObject<ComputeNode>;
-
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        compute: typeof compute;
-        computeKernel: typeof computeKernel;
+) => ComputeNode;
+
+declare module "../Nodes.js" {
+    interface Node {
+        compute: (
+            count: number,
+            workgroupSize?: number[],
+        ) => ComputeNode;
+        computeAssign: (
+            count: number,
+            workgroupSize?: number[],
+        ) => this;
+
+        computeKernel: (workgroupSize?: number[]) => ComputeNode;
+        computeKernelAssign: (workgroupSize?: number[]) => this;
     }
 }

three/src/nodes/gpgpu/SubgroupFunctionNode.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 SubgroupFunctionNodeMethod0 = typeof SubgroupFunctionNode.SUBGROUP_ELECT;
 
@@ -71,30 +70,30 @@ declare class SubgroupFunctionNode extends TempNode {
 
 export default SubgroupFunctionNode;
 
-export const subgroupElect: () => ShaderNodeObject<Node>;
+export const subgroupElect: () => Node;
 
-export const subgroupBallot: (pred: Node) => ShaderNodeObject<Node>;
-export const subgroupAdd: (e: Node) => ShaderNodeObject<Node>;
-export const subgroupInclusiveAdd: (e: Node) => ShaderNodeObject<Node>;
-export const subgroupExclusiveAdd: (e: Node) => ShaderNodeObject<Node>;
-export const subgroupMul: (e: Node) => ShaderNodeObject<Node>;
-export const subgroupInclusiveMul: (e: Node) => ShaderNodeObject<Node>;
-export const subgroupExclusiveMul: (e: Node) => ShaderNodeObject<Node>;
-export const subgroupAnd: (e: Node) => ShaderNodeObject<Node>;
-export const subgroupOr: (e: Node) => ShaderNodeObject<Node>;
-export const subgroupXor: (e: Node) => ShaderNodeObject<Node>;
-export const subgroupMin: (e: Node) => ShaderNodeObject<Node>;
-export const subgroupMax: (e: Node) => ShaderNodeObject<Node>;
-export const subgroupAll: () => ShaderNodeObject<Node>;
-export const subgroupAny: () => ShaderNodeObject<Node>;
-export const subgroupBroadcastFirst: (e: Node, id: Node) => ShaderNodeObject<Node>;
-export const quadSwapX: (e: Node) => ShaderNodeObject<Node>;
-export const quadSwapY: (e: Node) => ShaderNodeObject<Node>;
-export const quadSwapDiagonal: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupBallot: (pred: Node) => Node;
+export const subgroupAdd: (e: Node) => Node;
+export const subgroupInclusiveAdd: (e: Node) => Node;
+export const subgroupExclusiveAdd: (e: Node) => Node;
+export const subgroupMul: (e: Node) => Node;
+export const subgroupInclusiveMul: (e: Node) => Node;
+export const subgroupExclusiveMul: (e: Node) => Node;
+export const subgroupAnd: (e: Node) => Node;
+export const subgroupOr: (e: Node) => Node;
+export const subgroupXor: (e: Node) => Node;
+export const subgroupMin: (e: Node) => Node;
+export const subgroupMax: (e: Node) => Node;
+export const subgroupAll: () => Node;
+export const subgroupAny: () => Node;
+export const subgroupBroadcastFirst: (e: Node, id: Node) => Node;
+export const quadSwapX: (e: Node) => Node;
+export const quadSwapY: (e: Node) => Node;
+export const quadSwapDiagonal: (e: Node) => Node;
 
-export const subgroupBroadcast: (e: Node, id: Node) => ShaderNodeObject<Node>;
-export const subgroupShuffle: (v: Node, id: Node) => ShaderNodeObject<Node>;
-export const subgroupShuffleXor: (v: Node, mask: Node) => ShaderNodeObject<Node>;
-export const subgroupShuffleUp: (v: Node, delta: Node) => ShaderNodeObject<Node>;
-export const subgroupShuffleDown: (v: Node, delta: Node) => ShaderNodeObject<Node>;
-export const quadBroadcast: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupBroadcast: (e: Node, id: Node) => Node;
+export const subgroupShuffle: (v: Node, id: Node) => Node;
+export const subgroupShuffleXor: (v: Node, mask: Node) => Node;
+export const subgroupShuffleUp: (v: Node, delta: Node) => Node;
+export const subgroupShuffleDown: (v: Node, delta: Node) => Node;
+export const quadBroadcast: (e: Node) => Node;

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

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class WorkgroupInfoNode extends Node {
     bufferType: string;
@@ -16,4 +15,4 @@ declare class WorkgroupInfoNode extends Node {
 
 export default WorkgroupInfoNode;
 
-export const workgroupArray: (type: string, count?: number) => ShaderNodeObject<WorkgroupInfoNode>;
+export const workgroupArray: (type: string, count?: number) => WorkgroupInfoNode;

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

@@ -1,7 +1,6 @@
 import { Light } from "../../lights/Light.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import LightingNode from "./LightingNode.js";
 import { DirectLightData, DirectRectAreaLightData } from "./LightsNode.js";
 import ShadowNode from "./ShadowNode.js";
@@ -23,7 +22,7 @@ declare class AnalyticLightNode<T extends Light> extends LightingNode {
 
     setupDirectRectArea(builder: NodeBuilder): DirectRectAreaLightData | undefined;
 
-    setupShadowNode(): ShaderNodeObject<ShadowNode>;
+    setupShadowNode(): ShadowNode;
 
     setupShadow(builder: NodeBuilder): void;
 }

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

@@ -1,9 +1,8 @@
 import Node from "../core/Node.js";
 import ConditionalNode from "../math/ConditionalNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export const getDistanceAttenuation: (args: {
     lightDistance: Node;
     cutoffDistance: Node;
     decayExponent: Node;
-}) => ShaderNodeObject<ConditionalNode>;
+}) => ConditionalNode;

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

@@ -1,7 +1,6 @@
 import ContextNode from "../core/ContextNode.js";
 import LightingModel, { LightingModelReflectedLight } from "../core/LightingModel.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import LightsNode from "./LightsNode.js";
 
 export interface LightingContext {
@@ -32,4 +31,4 @@ export default class LightingContextNode extends ContextNode {
 export const lightingContext: (
     node: LightsNode,
     lightingModelNode?: LightingModel,
-) => ShaderNodeObject<LightingContextNode>;
+) => LightingContextNode;

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

@@ -1,7 +1,6 @@
 import { Light } from "../../lights/Light.js";
 import Node from "../core/Node.js";
 import { NodeBuilder } from "../Nodes.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import LightingNode from "./LightingNode.js";
 
 export interface DirectLightData {
@@ -44,4 +43,4 @@ declare class LightsNode extends Node {
 
 export default LightsNode;
 
-export const lights: (lights?: Light[]) => ShaderNodeObject<LightsNode>;
+export const lights: (lights?: Light[]) => LightsNode;

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

@@ -1,15 +1,14 @@
 import { PointLight } from "../../lights/PointLight.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import AnalyticLightNode from "./AnalyticLightNode.js";
 import { DirectLightData } from "./LightsNode.js";
 import PointShadowNode from "./PointShadowNode.js";
 
 export const directPointLight: (params: {
-    color: ShaderNodeObject<Node>;
-    lightViewPosition: ShaderNodeObject<Node>;
-    cutoffDistance: ShaderNodeObject<Node>;
-    decayExponent: ShaderNodeObject<Node>;
+    color: Node;
+    lightViewPosition: Node;
+    cutoffDistance: Node;
+    decayExponent: Node;
 }) => DirectLightData;
 
 declare class PointLightNode extends AnalyticLightNode<PointLight> {
@@ -18,7 +17,7 @@ declare class PointLightNode extends AnalyticLightNode<PointLight> {
 
     constructor(light?: PointLight | null);
 
-    setupShadowNode(): ShaderNodeObject<PointShadowNode>;
+    setupShadowNode(): PointShadowNode;
 }
 
 export default PointLightNode;

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

@@ -1,17 +1,16 @@
 import { Light } from "../../lights/Light.js";
 import { LightShadow } from "../../lights/LightShadow.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import ShadowNode from "./ShadowNode.js";
 
-export const cubeToUV: (pos: Node, texelSizeY: Node) => ShaderNodeObject<Node>;
+export const cubeToUV: (pos: Node, texelSizeY: Node) => Node;
 
 export const BasicPointShadowFilter: (
     depthTexture: Node,
     bd3D: Node,
     dp: Node,
     texelSize: Node,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 export const PointShadowFilter: (
     depthTexture: Node,
@@ -19,7 +18,7 @@ export const PointShadowFilter: (
     dp: Node,
     texelSize: Node,
     shadow: Node,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 declare class PointShadowNode extends ShadowNode {
     constructor(light: Light, shadow: LightShadow | null);
@@ -27,4 +26,4 @@ declare class PointShadowNode extends ShadowNode {
 
 export default PointShadowNode;
 
-export const pointShadow: (light: Light, shadow?: LightShadow | null) => ShaderNodeObject<PointShadowNode>;
+export const pointShadow: (light: Light, shadow?: LightShadow | null) => PointShadowNode;

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

@@ -1,7 +1,6 @@
 import { Light } from "../../lights/Light.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class ShadowBaseNode extends Node {
     light: Light;
@@ -13,6 +12,6 @@ declare class ShadowBaseNode extends Node {
     setupShadowPosition(builder: NodeBuilder): void;
 }
 
-export const shadowPositionWorld: ShaderNodeObject<Node>;
+export const shadowPositionWorld: Node;
 
 export default ShadowBaseNode;

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

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

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

@@ -8,7 +8,6 @@ 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";
 
@@ -35,4 +34,4 @@ declare class ShadowNode extends ShadowBaseNode {
 
 export default ShadowNode;
 
-export const shadow: (light: Light, shadow?: LightShadow) => ShaderNodeObject<ShadowNode>;
+export const shadow: (light: Light, shadow?: LightShadow) => ShadowNode;

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

@@ -1,7 +1,6 @@
 import { SpotLight } from "../../lights/SpotLight.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import AnalyticLightNode from "./AnalyticLightNode.js";
 
 declare class SpotLightNode extends AnalyticLightNode<SpotLight> {
@@ -17,7 +16,7 @@ declare class SpotLightNode extends AnalyticLightNode<SpotLight> {
 
     constructor(light?: SpotLight | null);
 
-    getLightCoord(builder: NodeBuilder): ShaderNodeObject<Node>;
+    getLightCoord(builder: NodeBuilder): Node;
 }
 
 declare module "three" {

three/src/nodes/materialx/MaterialXNodes.d.ts

@@ -1,21 +1,20 @@
 import Node from "../core/Node.js";
 import MathNode from "../math/MathNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import { mx_hsvtorgb, mx_rgbtohsv } from "./lib/mx_hsv.js";
 import { mx_srgb_texture_to_lin_rec709 } from "./lib/mx_transform_color.js";
 
-export const mx_aastep: (threshold: Node | number, value: Node | number) => ShaderNodeObject<MathNode>;
+export const mx_aastep: (threshold: Node | number, value: Node | number) => MathNode;
 
 export const mx_ramplr: (
     valuel: Node | number,
     valuer: Node | number,
     texcoord?: Node,
-) => ShaderNodeObject<MathNode>;
+) => MathNode;
 export const mx_ramptb: (
     valuet: Node | number,
     valueb: Node | number,
     texcoord?: Node,
-) => ShaderNodeObject<MathNode>;
+) => MathNode;
 
 export const mx_ramp4: (
     valuetl: Node | number,
@@ -23,50 +22,50 @@ export const mx_ramp4: (
     valuebl: Node | number,
     valuebr: Node | number,
     texcoord?: Node,
-) => ShaderNodeObject<MathNode>;
+) => MathNode;
 
 export const mx_splitlr: (
     valuel: Node | number,
     valuer: Node | number,
     center: Node | number,
     texcoord?: Node,
-) => ShaderNodeObject<MathNode>;
+) => MathNode;
 export const mx_splittb: (
     valuet: Node | number,
     valueb: Node | number,
     center: Node | number,
     texcoord?: Node,
-) => ShaderNodeObject<MathNode>;
+) => MathNode;
 
 export const mx_transform_uv: (
     uv_scale?: Node | number,
     uv_offset?: Node | number,
     uv_geo?: Node,
-) => ShaderNodeObject<Node>;
+) => Node;
 
-export const mx_safepower: (in1: Node | number, in2?: Node | number) => ShaderNodeObject<Node>;
+export const mx_safepower: (in1: Node | number, in2?: Node | number) => Node;
 
 export const mx_contrast: (
     input: Node | number,
     amount?: Node | number,
     pivot?: Node | number,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 export const mx_noise_float: (
     texcoord?: Node,
     amplitude?: Node | number,
     pivot?: Node | number,
-) => ShaderNodeObject<Node>;
+) => Node;
 export const mx_noise_vec3: (
     texcoord?: Node,
     amplitude?: Node | number,
     pivot?: Node | number,
-) => ShaderNodeObject<Node>;
+) => Node;
 export const mx_noise_vec4: (
     texcoord?: Node,
     amplitude?: Node | number,
     pivot?: Node | number,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 export const mx_unifiednoise2d: (
     noiseType: Node,
@@ -80,7 +79,7 @@ export const mx_unifiednoise2d: (
     octaves?: Node | number,
     lacunarity?: Node | number,
     diminish?: Node | number,
-) => ShaderNodeObject<Node>;
+) => Node;
 export const mx_unifiednoise3d: (
     noiseType: Node,
     texcoord?: Node,
@@ -93,22 +92,22 @@ export const mx_unifiednoise3d: (
     octaves?: Node | number,
     lacunarity?: Node | number,
     diminish?: Node | number,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 export function mx_worley_noise_float(
     texcoord?: Node,
     jitter?: Node | number,
-): ShaderNodeObject<Node>;
+): Node;
 export function mx_worley_noise_vec2(
     texcoord?: Node,
     jitter?: Node | number,
-): ShaderNodeObject<Node>;
+): Node;
 export function mx_worley_noise_vec3(
     texcoord?: Node,
     jitter?: Node | number,
-): ShaderNodeObject<Node>;
+): Node;
 
-export function mx_cell_noise_float(texcoord?: Node): ShaderNodeObject<Node>;
+export function mx_cell_noise_float(texcoord?: Node): Node;
 
 export function mx_fractal_noise_float(
     position?: Node,
@@ -116,46 +115,46 @@ export function mx_fractal_noise_float(
     lacunarity?: Node | number,
     diminish?: Node | number,
     amplitude?: Node | number,
-): ShaderNodeObject<Node>;
+): Node;
 export function mx_fractal_noise_vec2(
     position?: Node,
     octaves?: Node | number,
     lacunarity?: Node | number,
     diminish?: Node | number,
     amplitude?: Node | number,
-): ShaderNodeObject<Node>;
+): Node;
 export function mx_fractal_noise_vec3(
     position?: Node,
     octaves?: Node | number,
     lacunarity?: Node | number,
     diminish?: Node | number,
     amplitude?: Node | number,
-): ShaderNodeObject<Node>;
+): Node;
 export function mx_fractal_noise_vec4(
     position?: Node,
     octaves?: Node | number,
     lacunarity?: Node | number,
     diminish?: Node | number,
     amplitude?: Node | number,
-): ShaderNodeObject<Node>;
+): Node;
 
 export { mx_hsvtorgb, mx_rgbtohsv, mx_srgb_texture_to_lin_rec709 };
 
-export const mx_add: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
-export const mx_subtract: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
-export const mx_multiply: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
-export const mx_divide: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
-export const mx_modulo: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
-export const mx_power: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
-export const mx_atan2: (in1?: Node, in2?: Node) => ShaderNodeObject<Node>;
-export const mx_timer: () => ShaderNodeObject<Node>;
-export const mx_frame: () => ShaderNodeObject<Node>;
-export const mx_invert: (in1: Node, amount?: Node) => ShaderNodeObject<Node>;
-export const mx_ifgreater: (value1: Node, value2: Node, in1: Node, in2: Node) => ShaderNodeObject<Node>;
-export const mx_ifgreatereq: (value1: Node, value2: Node, in1: Node, in2: Node) => ShaderNodeObject<Node>;
-export const mx_ifequal: (value1: Node, value2: Node, in1: Node, in2: Node) => ShaderNodeObject<Node>;
-
-export const mx_separate: (in1: Node, channelOrOut?: string | number) => ShaderNodeObject<Node>;
+export const mx_add: (in1: Node, in2?: Node) => Node;
+export const mx_subtract: (in1: Node, in2?: Node) => Node;
+export const mx_multiply: (in1: Node, in2?: Node) => Node;
+export const mx_divide: (in1: Node, in2?: Node) => Node;
+export const mx_modulo: (in1: Node, in2?: Node) => Node;
+export const mx_power: (in1: Node, in2?: Node) => Node;
+export const mx_atan2: (in1?: Node, in2?: Node) => Node;
+export const mx_timer: () => Node;
+export const mx_frame: () => Node;
+export const mx_invert: (in1: Node, amount?: Node) => Node;
+export const mx_ifgreater: (value1: Node, value2: Node, in1: Node, in2: Node) => Node;
+export const mx_ifgreatereq: (value1: Node, value2: Node, in1: Node, in2: Node) => Node;
+export const mx_ifequal: (value1: Node, value2: Node, in1: Node, in2: Node) => Node;
+
+export const mx_separate: (in1: Node, channelOrOut?: string | number) => Node;
 
 export const mx_place2d: (
     texcoord: Node,
@@ -163,10 +162,10 @@ export const mx_place2d: (
     scale?: Node,
     rotate?: Node,
     offset?: Node,
-) => ShaderNodeObject<Node>;
+) => Node;
 
-export const mx_rotate2d: (input: Node, amount: Node) => ShaderNodeObject<Node>;
+export const mx_rotate2d: (input: Node, amount: Node) => Node;
 
-export const mx_rotate3d: (input: Node, amount: Node, axis: Node) => ShaderNodeObject<Node>;
+export const mx_rotate3d: (input: Node, amount: Node, axis: Node) => Node;
 
-export const mx_heighttonormal: (input: Node, scale: Node) => ShaderNodeObject<Node>;
+export const mx_heighttonormal: (input: Node, scale: Node) => Node;