@types/three 0.158.3 → 0.160.0

three/examples/jsm/nodes/display/ColorAdjustmentNode.d.ts

@@ -1,5 +1,6 @@
 import TempNode from '../core/TempNode.js';
-import { Node } from '../Nodes.js';
+import MathNode from '../math/MathNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type ColorAdjustmentMethod =
     | typeof ColorAdjustmentNode.SATURATION
@@ -18,3 +19,19 @@ export default class ColorAdjustmentNode extends TempNode {
 
     constructor(method: ColorAdjustmentMethod, colorNode: Node, adjustmentNode?: Node);
 }
+
+export const saturation: (
+    colorNode: NodeRepresentation,
+    adjustmentNode?: NodeRepresentation,
+) => ShaderNodeObject<ColorAdjustmentNode>;
+export const vibrance: (
+    colorNode: NodeRepresentation,
+    adjustmentNode?: NodeRepresentation,
+) => ShaderNodeObject<ColorAdjustmentNode>;
+export const hue: (
+    colorNode: NodeRepresentation,
+    adjustmentNode?: NodeRepresentation,
+) => ShaderNodeObject<ColorAdjustmentNode>;
+
+export const lumaCoeffs: ShaderNodeObject<MathNode>;
+export const luminance: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<MathNode>;

three/examples/jsm/nodes/display/ColorSpaceNode.d.ts

@@ -1,5 +1,7 @@
+import { TextureEncoding } from '../../../../src/Three.js';
 import TempNode from '../core/TempNode.js';
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type ColorSpaceNodeMethod =
     | typeof ColorSpaceNode.LINEAR_TO_LINEAR
@@ -16,3 +18,5 @@ export default class ColorSpaceNode extends TempNode {
 
     constructor(method: ColorSpaceNodeMethod | null, node: Node);
 }
+
+export const colorSpace: (node: NodeRepresentation, encoding: TextureEncoding) => ShaderNodeObject<ColorSpaceNode>;

three/examples/jsm/nodes/display/FrontFacingNode.d.ts

@@ -1,6 +1,10 @@
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class FrontFacingNode extends Node {
     isFrontFacingNode: true;
     constructor();
 }
+
+export const frontFacing: ShaderNodeObject<FrontFacingNode>;
+export const faceDirection: ShaderNodeObject<Node>;

three/examples/jsm/nodes/display/NormalMapNode.d.ts

@@ -1,6 +1,8 @@
-import TempNode from '../core/TempNode.js';
 import { NormalMapTypes } from '../../../../src/Three.js';
+import TempNode from '../core/TempNode.js';
 import Node from '../core/Node.js';
+import MathNode from '../math/MathNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class NormalMapNode extends TempNode {
     node: Node;
@@ -10,3 +12,7 @@ export default class NormalMapNode extends TempNode {
 
     constructor(node: Node, scaleNode?: Node | null);
 }
+
+export const normalMap: (node: Node, scaleNode?: Node) => ShaderNodeObject<NormalMapNode>;
+
+export const TBNViewMatrix: ShaderNodeObject<MathNode>;

three/examples/jsm/nodes/display/PosterizeNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class PosterizeNode extends Node {
     sourceNode: Node;
@@ -6,3 +7,8 @@ export default class PosterizeNode extends Node {
 
     constructor(sourceNode: Node, stepsNode: Node);
 }
+
+export const posterize: (
+    sourceNode: NodeRepresentation,
+    stepsNode: NodeRepresentation,
+) => ShaderNodeObject<PosterizeNode>;

three/examples/jsm/nodes/display/ToneMappingNode.d.ts

@@ -1,6 +1,7 @@
+import { ToneMapping } from '../../../../src/Three.js';
 import TempNode from '../core/TempNode.js';
 import Node from '../core/Node.js';
-import { ToneMapping } from '../../../../src/Three.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 // exposure only
 export const LinearToneMappingNode: Node;
@@ -12,3 +13,9 @@ export default class ToneMappingNode extends TempNode {
 
     constructor(toneMapping: ToneMapping, exposureNode?: Node, colorNode?: Node | null);
 }
+
+export const toneMapping: (
+    mapping: ToneMapping,
+    exposure: NodeRepresentation,
+    color?: NodeRepresentation,
+) => ShaderNodeObject<ToneMappingNode>;

three/examples/jsm/nodes/display/ViewportNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type ViewportNodeScope =
     | typeof ViewportNode.COORDINATE
@@ -21,3 +22,10 @@ export default class ViewportNode extends Node {
 
     constructor(scope: ViewportNodeScope);
 }
+
+export const viewportCoordinate: ShaderNodeObject<ViewportNode>;
+export const viewportResolution: ShaderNodeObject<ViewportNode>;
+export const viewportTopLeft: ShaderNodeObject<ViewportNode>;
+export const viewportBottomLeft: ShaderNodeObject<ViewportNode>;
+export const viewportTopRight: ShaderNodeObject<ViewportNode>;
+export const viewportBottomRight: ShaderNodeObject<ViewportNode>;

three/examples/jsm/nodes/fog/FogExp2Node.d.ts

@@ -1,5 +1,6 @@
 import Node from '../core/Node.js';
 import FogNode from './FogNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class FogExp2Node extends FogNode {
     isFogExp2Node: true;
@@ -7,3 +8,5 @@ export default class FogExp2Node extends FogNode {
 
     constructor(colorNode: Node, densityNode: Node);
 }
+
+export const densityFog: (colorNode: Node, densityNode: Node) => ShaderNodeObject<FogExp2Node>;

three/examples/jsm/nodes/fog/FogNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class FogNode extends Node {
     isFogNode: true;
@@ -8,3 +9,5 @@ export default class FogNode extends Node {
     constructor(colorNode: Node, factorNode: Node);
     mixAssign(outputNode: Node): Node;
 }
+
+export const fog: (colorNode: NodeRepresentation, factorNode: NodeRepresentation) => ShaderNodeObject<FogNode>;

three/examples/jsm/nodes/fog/FogRangeNode.d.ts

@@ -1,5 +1,6 @@
 import FogNode from './FogNode.js';
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class FogRangeNode extends FogNode {
     isFogRangeNode: true;
@@ -8,3 +9,5 @@ export default class FogRangeNode extends FogNode {
 
     constructor(colorNode: Node, nearNode: Node, farNode: Node);
 }
+
+export const rangeFog: (colorNode: Node, nearNode: Node, farNode: Node) => ShaderNodeObject<FogRangeNode>;

three/examples/jsm/nodes/functions/BSDF/BRDF_GGX.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.js';
 import Node from '../../core/Node.js';
 
 declare const BRDF_GGX: ShaderNode<{ lightDirection: Node; f0: Node; f90: Node; roughness: Node }>;

three/examples/jsm/nodes/functions/BSDF/BRDF_Lambert.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.js';
 import Node from '../../core/Node.js';
 
 declare const BRDF_Lambert: ShaderNode<{ diffuseColor: Node }>;

three/examples/jsm/nodes/functions/BSDF/DFGApprox.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeElements.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.js';
 import Node from '../../core/Node.js';
 
 // Analytical approximation of the DFG LUT, one half of the

three/examples/jsm/nodes/functions/BSDF/D_GGX.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.js';
 import Node from '../../core/Node.js';
 
 // Microfacet Models for Refraction through Rough Surfaces - equation (33)

three/examples/jsm/nodes/functions/BSDF/F_Schlick.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.js';
 import Node from '../../core/Node.js';
 
 declare const F_Schlick: ShaderNode<{ f0: Node; f90: Node; dotVH: Node }>;

three/examples/jsm/nodes/functions/BSDF/V_GGX_SmithCorrelated.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.js';
 import Node from '../../core/Node.js';
 
 declare const V_GGX_SmithCorrelated: ShaderNode<{ alpha: Node; dotNL: Node; dotNV: Node }>;

three/examples/jsm/nodes/functions/PhysicalLightingModel.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNode } from '../shadernode/ShaderNodeElements.js';
+import { ShaderNode } from '../shadernode/ShaderNode.js';
 import Node from '../core/Node.js';
 
 declare const PhysicalLightingModel: {

three/examples/jsm/nodes/functions/material/getGeometryRoughness.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.js';
 
 declare const getGeometryRoughness: ShaderNode;
 

three/examples/jsm/nodes/functions/material/getRoughness.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeElements.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.js';
 import Node from '../../core/Node.js';
 
 declare const getRoughness: ShaderNode<{ roughness: Node }>;

three/examples/jsm/nodes/geometry/RangeNode.d.ts

@@ -1,6 +1,7 @@
 import { Color, Vector2, Vector3, Vector4 } from '../../../../src/Three.js';
 import Node from '../core/Node.js';
 import NodeBuilder from '../core/NodeBuilder.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type RangeModeBound = number | Color | Vector2 | Vector3 | Vector4;
 
@@ -11,3 +12,5 @@ export default class RangeNode extends Node {
     constructor(min: RangeModeBound, max: RangeModeBound);
     getVectorLength(builder: NodeBuilder): number;
 }
+
+export const range: (min: RangeModeBound, max: RangeModeBound) => ShaderNodeObject<RangeNode>;

three/examples/jsm/nodes/gpgpu/ComputeNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class ComputeNode extends Node {
     isComputeNode: true;
@@ -9,3 +10,9 @@ export default class ComputeNode extends Node {
 
     constructor(computeNode: Node, count: number, workgroupSize?: number[]);
 }
+
+export const compute: (
+    node: NodeRepresentation,
+    count: number,
+    workgroupSize: number[],
+) => ShaderNodeObject<ComputeNode>;

three/examples/jsm/nodes/lighting/LightingContextNode.d.ts

@@ -1,6 +1,6 @@
 import ContextNode from '../core/ContextNode.js';
 import Node from '../core/Node.js';
-import { ShaderNode } from '../Nodes.js';
+import { ShaderNode, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export interface LightingModelNode {
     indirectDiffuse?: ShaderNode;
@@ -13,3 +13,8 @@ export default class LightingContextNode extends ContextNode {
 
     constructor(node: Node, lightingModelNode?: LightingModelNode | null);
 }
+
+export const lightingContext: (
+    node: Node,
+    lightingModelNode?: LightingModelNode,
+) => ShaderNodeObject<LightingContextNode>;

three/examples/jsm/nodes/lighting/LightsNode.d.ts

@@ -1,6 +1,7 @@
 import { Light } from '../../../../src/Three.js';
 import Node from '../core/Node.js';
 import LightingNode from './LightingNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class LightsNode extends Node {
     lightNodes: LightingNode[];
@@ -17,3 +18,5 @@ export default class LightsNode extends Node {
         lightNodeClass: { new (light: T): LightingNode },
     ): void;
 }
+
+export const lights: (lights: Light[]) => ShaderNodeObject<LightsNode>;

three/examples/jsm/nodes/materials/MeshPhysicalNodeMaterial.d.ts

@@ -1,12 +1,25 @@
 import { ShaderMaterialParameters } from '../../../../src/Three.js';
-import { Swizzable, CheckerNode, Node } from '../Nodes.js';
 
 import MeshStandardNodeMaterial from './MeshStandardNodeMaterial.js';
+import Node from '../core/Node.js';
+import CheckerNode from '../procedural/CheckerNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
-    iridescenceNode: null | Swizzable<CheckerNode>;
-    iridescenceIORNode: null | Swizzable;
-    iridescenceThicknessNode: null | Swizzable;
+    readonly isMeshPhysicalNodeMaterial: true;
+
+    clearcoatNode: Node | null;
+    clearcoatRoughnessNode: Node | null;
+    clearcoatNormalNode: Node | null;
+
+    sheenNode: Node | null;
+    sheenRoughnessNode: Node | null;
+
+    iridescenceNode: null | ShaderNodeObject<CheckerNode>;
+    iridescenceIORNode: null | ShaderNodeObject<Node>;
+    iridescenceThicknessNode: null | ShaderNodeObject<Node>;
+
+    iorNode?: Node | null;
 
     specularIntensityNode: Node | null;
     specularColorNode: Node | null;
@@ -16,7 +29,7 @@ export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
     attenuationDistanceNode: Node | null;
     attenuationColorNode: Node | null;
 
-    constructor(parameters: ShaderMaterialParameters);
+    constructor(parameters?: ShaderMaterialParameters);
 
     copy(source: MeshPhysicalNodeMaterial): this;
 }

three/examples/jsm/nodes/materials/MeshStandardNodeMaterial.d.ts

@@ -10,9 +10,6 @@ export default class MeshStandardNodeMaterial extends NodeMaterial {
     metalnessNode: Node | null;
     roughnessNode: Node | null;
 
-    clearcoatNode: Node | null;
-    clearcoatRoughnessNode: Node | null;
-
     constructor(paramters?: ShaderMaterialParameters);
     copy(source: MeshStandardNodeMaterial): this;
 }

three/examples/jsm/nodes/materials/NodeMaterial.d.ts

@@ -1,7 +1,22 @@
-import { Material, ShaderMaterial } from '../../../../src/Three.js';
+import {
+    LineBasicMaterial,
+    Material,
+    MeshBasicMaterial,
+    MeshPhysicalMaterial,
+    MeshStandardMaterial,
+    PointsMaterial,
+    ShaderMaterial,
+    SpriteMaterial,
+} from '../../../../src/Three.js';
 import NodeBuilder from '../core/NodeBuilder.js';
 import Node from '../core/Node.js';
 import { LightingModelNode } from '../lighting/LightingContextNode.js';
+import LineBasicNodeMaterial from './LineBasicNodeMaterial.js';
+import MeshBasicNodeMaterial from './MeshBasicNodeMaterial.js';
+import MeshPhysicalNodeMaterial from './MeshPhysicalNodeMaterial.js';
+import MeshStandardNodeMaterial from './MeshStandardNodeMaterial.js';
+import PointsNodeMaterial from './PointsNodeMaterial.js';
+import SpriteNodeMaterial from './SpriteNodeMaterial.js';
 
 export default class NodeMaterial extends ShaderMaterial {
     isNodeMaterial: true;
@@ -34,5 +49,13 @@ export default class NodeMaterial extends ShaderMaterial {
         lights: { diffuseColorNode: Node; lightingModelNode: LightingModelNode; lightsNode?: Node },
     ): void;
     generateOutput(builder: NodeBuilder, lights: { diffuseColorNode: Node; outgoingLightNode: Node }): void;
-    static fromMaterial(m: Material): NodeMaterial;
+
+    static fromMaterial(material: LineBasicMaterial): LineBasicNodeMaterial;
+    static fromMaterial(material: MeshBasicMaterial): MeshBasicNodeMaterial;
+    static fromMaterial(material: MeshPhysicalMaterial): MeshPhysicalNodeMaterial;
+    static fromMaterial(material: MeshStandardMaterial): MeshStandardNodeMaterial;
+    static fromMaterial(material: PointsMaterial): PointsNodeMaterial;
+    static fromMaterial(material: SpriteMaterial): SpriteNodeMaterial;
+    static fromMaterial(material: NodeMaterial): NodeMaterial;
+    static fromMaterial(material: Material): NodeMaterial;
 }

three/examples/jsm/nodes/materialx/MaterialXNodes.d.ts

@@ -1,94 +1,103 @@
 import { mx_hsvtorgb, mx_rgbtohsv } from './lib/mx_hsv.js';
-import { Swizzable } from '../shadernode/ShaderNodeElements.js';
-import { UVNode, MathNode } from '../Nodes.js';
-import { NodeRepresentation } from '../shadernode/ShaderNode.js';
+import Node from '../core/Node.js';
+import MathNode from '../math/MathNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
-export function mx_aastep(threshold?: NodeRepresentation, value?: NodeRepresentation): Swizzable<MathNode>;
+export function mx_aastep(threshold?: NodeRepresentation, value?: NodeRepresentation): ShaderNodeObject<MathNode>;
 
 export function mx_ramplr(
     valuel?: NodeRepresentation,
     valuer?: NodeRepresentation,
-    texcoord?: Swizzable<UVNode>,
-): Swizzable<MathNode>;
+    texcoord?: ShaderNodeObject<Node>,
+): ShaderNodeObject<MathNode>;
 export function mx_ramptb(
     valuet?: NodeRepresentation,
     valueb?: NodeRepresentation,
-    texcoord?: Swizzable<UVNode>,
-): Swizzable<MathNode>;
+    texcoord?: ShaderNodeObject<Node>,
+): ShaderNodeObject<MathNode>;
 
 export function mx_splitlr(
     valuel?: NodeRepresentation,
     valuer?: NodeRepresentation,
     center?: NodeRepresentation,
-    texcoord?: Swizzable<UVNode>,
-): Swizzable<MathNode>;
+    texcoord?: ShaderNodeObject<Node>,
+): ShaderNodeObject<MathNode>;
 export function mx_splittb(
     valuet?: NodeRepresentation,
     valueb?: NodeRepresentation,
     center?: NodeRepresentation,
-    texcoord?: Swizzable<UVNode>,
-): Swizzable<MathNode>;
+    texcoord?: ShaderNodeObject<Node>,
+): ShaderNodeObject<MathNode>;
 
 export function mx_transform_uv(
     uv_scale?: NodeRepresentation,
     uv_offset?: NodeRepresentation,
-    uv_geo?: Swizzable<UVNode>,
-): Swizzable;
+    uv_geo?: ShaderNodeObject<Node>,
+): ShaderNodeObject<Node>;
 
 export function mx_noise_float(
-    texcoord?: Swizzable<UVNode>,
+    texcoord?: ShaderNodeObject<Node>,
     amplitude?: NodeRepresentation,
     pivot?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 export function mx_noise_vec2(
-    texcoord?: Swizzable<UVNode>,
+    texcoord?: ShaderNodeObject<Node>,
     amplitude?: NodeRepresentation,
     pivot?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 export function mx_noise_vec3(
-    texcoord?: Swizzable<UVNode>,
+    texcoord?: ShaderNodeObject<Node>,
     amplitude?: NodeRepresentation,
     pivot?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 export function mx_noise_vec4(
-    texcoord?: Swizzable<UVNode>,
+    texcoord?: ShaderNodeObject<Node>,
     amplitude?: NodeRepresentation,
     pivot?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 
-export function mx_worley_noise_float(texcoord?: Swizzable<UVNode>, jitter?: NodeRepresentation): Swizzable;
-export function mx_worley_noise_vec2(texcoord?: Swizzable<UVNode>, jitter?: NodeRepresentation): Swizzable;
-export function mx_worley_noise_vec3(texcoord?: Swizzable<UVNode>, jitter?: NodeRepresentation): Swizzable;
+export function mx_worley_noise_float(
+    texcoord?: ShaderNodeObject<Node>,
+    jitter?: NodeRepresentation,
+): ShaderNodeObject<Node>;
+export function mx_worley_noise_vec2(
+    texcoord?: ShaderNodeObject<Node>,
+    jitter?: NodeRepresentation,
+): ShaderNodeObject<Node>;
+export function mx_worley_noise_vec3(
+    texcoord?: ShaderNodeObject<Node>,
+    jitter?: NodeRepresentation,
+): ShaderNodeObject<Node>;
 
-export function mx_cell_noise_float(texcoord?: Swizzable<UVNode>): Swizzable;
+export function mx_cell_noise_float(texcoord?: ShaderNodeObject<Node>): ShaderNodeObject<Node>;
 
 export function mx_fractal_noise_float(
-    position?: Swizzable<UVNode>,
+    position?: ShaderNodeObject<Node>,
     octaves?: NodeRepresentation,
     lacunarity?: NodeRepresentation,
     diminish?: NodeRepresentation,
     amplitude?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 export function mx_fractal_noise_vec2(
-    position?: Swizzable<UVNode>,
+    position?: ShaderNodeObject<Node>,
     octaves?: NodeRepresentation,
     lacunarity?: NodeRepresentation,
     diminish?: NodeRepresentation,
     amplitude?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 export function mx_fractal_noise_vec3(
-    position?: Swizzable<UVNode>,
+    position?: ShaderNodeObject<Node>,
     octaves?: NodeRepresentation,
     lacunarity?: NodeRepresentation,
     diminish?: NodeRepresentation,
     amplitude?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 export function mx_fractal_noise_vec4(
-    position?: Swizzable<UVNode>,
+    position?: ShaderNodeObject<Node>,
     octaves?: NodeRepresentation,
     lacunarity?: NodeRepresentation,
     diminish?: NodeRepresentation,
     amplitude?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 
 export { mx_hsvtorgb, mx_rgbtohsv };

three/examples/jsm/nodes/materialx/lib/mx_hsv.d.ts

@@ -1,4 +1,6 @@
-import { Fn, Node, Swizzable } from '../../Nodes.js';
+import Node from '../../core/Node.js';
+import { Fn } from '../../code/FunctionNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
 
-export function mx_hsvtorgb(...params: Fn<[Node]>): Swizzable;
-export function mx_rgbtohsv(...params: Fn<[Node]>): Swizzable;
+export function mx_hsvtorgb(...params: Fn<[Node]>): ShaderNodeObject<Node>;
+export function mx_rgbtohsv(...params: Fn<[Node]>): ShaderNodeObject<Node>;

three/examples/jsm/nodes/materialx/lib/mx_noise.d.ts

@@ -1,6 +1,8 @@
-import { Fn, Node, Swizzable } from '../../Nodes.js';
+import Node from '../../core/Node.js';
+import { Fn } from '../../code/FunctionNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
 
-export function mx_perlin_noise_float(...params: Fn<[Node]>): Swizzable;
-export function mx_cell_noise_float(...params: Fn<[Node]>): Swizzable;
-export function mx_worley_noise_float(...params: Fn<[Node]>): Swizzable;
-export function mx_fractal_noise_float(...params: Fn<[Node, Node, Node, Node]>): Swizzable;
+export function mx_perlin_noise_float(...params: Fn<[Node]>): ShaderNodeObject<Node>;
+export function mx_cell_noise_float(...params: Fn<[Node]>): ShaderNodeObject<Node>;
+export function mx_worley_noise_float(...params: Fn<[Node]>): ShaderNodeObject<Node>;
+export function mx_fractal_noise_float(...params: Fn<[Node, Node, Node, Node]>): ShaderNodeObject<Node>;

three/examples/jsm/nodes/math/CondNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class CondNode extends Node {
     condNode: Node;
@@ -7,3 +8,9 @@ export default class CondNode extends Node {
 
     constructor(condNode: Node, ifNode: Node, elseNode: Node);
 }
+
+export function cond(
+    condNode: NodeRepresentation,
+    ifNode: NodeRepresentation,
+    elseNode: NodeRepresentation,
+): ShaderNodeObject<Node>;