@types/three 0.162.0 → 0.164.0

three/examples/jsm/nodes/core/PropertyNode.d.ts

@@ -24,9 +24,19 @@ export const sheenRoughness: ShaderNodeObject<PropertyNode>;
 export const iridescence: ShaderNodeObject<PropertyNode>;
 export const iridescenceIOR: ShaderNodeObject<PropertyNode>;
 export const iridescenceThickness: ShaderNodeObject<PropertyNode>;
+export const alphaT: ShaderNodeObject<PropertyNode>;
+export const anisotropy: ShaderNodeObject<PropertyNode>;
+export const anisotropyT: ShaderNodeObject<PropertyNode>;
+export const anisotropyB: ShaderNodeObject<PropertyNode>;
 export const specularColor: ShaderNodeObject<PropertyNode>;
+export const specularF90: ShaderNodeObject<PropertyNode>;
 export const shininess: ShaderNodeObject<PropertyNode>;
 export const output: ShaderNodeObject<PropertyNode>;
 export const dashSize: ShaderNodeObject<PropertyNode>;
 export const gapSize: ShaderNodeObject<PropertyNode>;
 export const pointWidth: ShaderNodeObject<PropertyNode>;
+export const ior: ShaderNodeObject<PropertyNode>;
+export const transmission: ShaderNodeObject<PropertyNode>;
+export const thickness: ShaderNodeObject<PropertyNode>;
+export const attenuationDistance: ShaderNodeObject<PropertyNode>;
+export const attenuationColor: ShaderNodeObject<PropertyNode>;

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

@@ -25,6 +25,8 @@ export default class PassNode extends TempNode {
 
     getTextureDepthNode(): ShaderNodeObject<PassTextureNode>;
 
+    getViewZNode(): ShaderNodeObject<Node>;
+
     getDepthNode(): ShaderNodeObject<Node>;
 
     setSize(width: number, height: number): void;

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

@@ -1,4 +1,5 @@
 import { ToneMapping } from "three";
+import RendererReferenceNode from "../accessors/RendererReferenceNode.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
 import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
@@ -19,3 +20,14 @@ export const toneMapping: (
     exposure: NodeRepresentation,
     color?: NodeRepresentation,
 ) => ShaderNodeObject<ToneMappingNode>;
+export const toneMappingExposure: ShaderNodeObject<RendererReferenceNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        toneMapping: (
+            color: NodeRepresentation,
+            mapping?: NodeRepresentation,
+            exposure?: NodeRepresentation,
+        ) => ShaderNodeObject<ToneMappingNode>;
+    }
+}

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

@@ -1,16 +1,21 @@
 import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
 import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class FogNode extends Node {
     isFogNode: true;
-    colorNode: Node;
-    factorNode: Node;
+    colorNode: Node | null;
+    factorNode: Node | null;
 
-    constructor(colorNode: Node, factorNode: Node);
-    mixAssign(outputNode: Node): Node;
+    constructor(colorNode: Node | null, factorNode: Node | null);
+
+    getViewZNode(builder: NodeBuilder): Node;
 }
 
-export const fog: (colorNode: NodeRepresentation, factorNode: NodeRepresentation) => ShaderNodeObject<FogNode>;
+export const fog: (
+    colorNode: NodeRepresentation | null,
+    factorNode: NodeRepresentation | null,
+) => ShaderNodeObject<FogNode>;
 
 declare module "../shadernode/ShaderNode.js" {
     interface NodeElements {

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

@@ -1,16 +1,20 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import FogNode from "./FogNode.js";
 
 export default class FogRangeNode extends FogNode {
     isFogRangeNode: true;
-    nearNode: Node;
-    farNode: Node;
+    nearNode: Node | null;
+    farNode: Node | null;
 
-    constructor(colorNode: Node, nearNode: Node, farNode: Node);
+    constructor(colorNode: Node | null, nearNode: Node | null, farNode: Node | null);
 }
 
-export const rangeFog: (colorNode: Node, nearNode: Node, farNode: Node) => ShaderNodeObject<FogRangeNode>;
+export const rangeFog: (
+    colorNode: NodeRepresentation | null,
+    nearNode: NodeRepresentation | null,
+    farNode: NodeRepresentation | null,
+) => ShaderNodeObject<FogRangeNode>;
 
 declare module "../shadernode/ShaderNode.js" {
     interface NodeElements {

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

@@ -7,7 +7,9 @@ declare const BRDF_GGX: (args: {
     f0: Node;
     f90: Node;
     roughness: Node;
-    iridescenceFresnel?: Node;
+    f?: Node;
+    USE_IRIDESCENCE?: Node;
+    USE_ANISOTROPY?: Node;
 }) => ShaderNodeObject<OperatorNode>;
 
 export default BRDF_GGX;

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

@@ -0,0 +1,10 @@
+import Node from "../../core/Node.js";
+import OperatorNode from "../../math/OperatorNode.js";
+import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
+
+// https://google.github.io/filament/Filament.md.html#materialsystem/anisotropicmodel/anisotropicspecularbrdf
+declare const D_GGX_Anisotropic: (
+    args: { alphaT: Node; alphaB: Node; dotNH: Node; dotTH: Node; dotBH: Node },
+) => ShaderNodeObject<OperatorNode>;
+
+export default D_GGX_Anisotropic;

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

@@ -1,6 +1,11 @@
 import Node from "../../core/Node.js";
-import { ShaderNode } from "../../shadernode/ShaderNode.js";
+import OperatorNode from "../../math/OperatorNode.js";
+import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
 
-declare const V_GGX_SmithCorrelated: ShaderNode<{ alpha: Node; dotNL: Node; dotNV: Node }>;
+declare const V_GGX_SmithCorrelated: (inputs: {
+    alpha: Node;
+    dotNL: Node;
+    dotNV: Node;
+}) => ShaderNodeObject<OperatorNode>;
 
 export default V_GGX_SmithCorrelated;

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

@@ -0,0 +1,16 @@
+import Node from "../../core/Node.js";
+import MathNode from "../../math/MathNode";
+import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
+
+declare const V_GGX_SmithCorrelated: (inputs: {
+    alphaT: Node;
+    alphaB: Node;
+    dotTV: Node;
+    dotBV: Node;
+    dotTL: Node;
+    dotBL: Node;
+    dotNV: Node;
+    dotNL: Node;
+}) => ShaderNodeObject<MathNode>;
+
+export default V_GGX_SmithCorrelated;

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

@@ -5,6 +5,8 @@ export default class PhysicalLightingModel extends LightingModel {
     clearcoat: boolean;
     sheen: boolean;
     iridescence: boolean;
+    anisotropy: boolean;
+    transmission: boolean;
 
     clearcoatRadiance: Node | null;
     clearcoatSpecularDirect: Node | null;
@@ -14,7 +16,13 @@ export default class PhysicalLightingModel extends LightingModel {
     iridescenceFresnel: Node | null;
     iridescenceF0: Node | null;
 
-    constructor(clearcoat?: boolean, sheen?: boolean, iridescence?: boolean);
+    constructor(
+        clearcoat?: boolean,
+        sheen?: boolean,
+        iridescence?: boolean,
+        anisotropy?: boolean,
+        transmission?: boolean,
+    );
 
-    computeMultiscattering(singleScatter: Node, multiScatter: Node, specularF90?: Node): void;
+    computeMultiscattering(singleScatter: Node, multiScatter: Node, specularF90: Node): void;
 }

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

@@ -0,0 +1,9 @@
+import LightingModel from "../core/LightingModel.js";
+import VarNode from "../core/VarNode.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class ShadowMaskModel extends LightingModel {
+    shadowNode: ShaderNodeObject<VarNode>;
+
+    constructor();
+}

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

@@ -1,5 +1,6 @@
-import { ShaderNode } from "../../shadernode/ShaderNode.js";
+import MathNode from "../../math/MathNode.js";
+import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
 
-declare const getGeometryRoughness: ShaderNode;
+declare const getGeometryRoughness: () => ShaderNodeObject<MathNode>;
 
 export default getGeometryRoughness;

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

@@ -1,6 +1,7 @@
 import Node from "../../core/Node.js";
-import { ShaderNode } from "../../shadernode/ShaderNode.js";
+import MathNode from "../../math/MathNode.js";
+import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
 
-declare const getRoughness: ShaderNode<{ roughness: Node }>;
+declare const getRoughness: (args: { roughness: Node }) => ShaderNodeObject<MathNode>;
 
 export default getRoughness;

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

@@ -1,10 +1,8 @@
 import { Light } from "three";
-import Node from "../core/Node.js";
 import LightingNode from "./LightingNode.js";
 
 export default class AnalyticLightNode<T extends Light> extends LightingNode {
     light: T | null;
-    colorNode: Node;
 
     constructor(light?: T | null);
 }

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

@@ -0,0 +1,8 @@
+import Node from "../core/Node.js";
+import LightingNode from "./LightingNode.js";
+
+export default class IrradianceNode extends LightingNode {
+    node: Node | null;
+
+    constructor(node?: Node | null);
+}

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

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

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

@@ -1,9 +1,11 @@
 export { default as LineBasicNodeMaterial } from "./LineBasicNodeMaterial.js";
 export { default as MeshBasicNodeMaterial } from "./MeshBasicNodeMaterial.js";
+export { default as MeshNormalNodeMaterial } from "./MeshNormalNodeMaterial.js";
 export { default as MeshPhongNodeMaterial } from "./MeshPhongNodeMaterial.js";
 export { default as MeshPhysicalNodeMaterial } from "./MeshPhysicalNodeMaterial.js";
 export { default as MeshSSSPhysicalNodeMaterial } from "./MeshSSSNodeMaterial.js";
 export { default as MeshStandardNodeMaterial } from "./MeshStandardNodeMaterial.js";
 export { default as NodeMaterial } from "./NodeMaterial.js";
 export { default as PointsNodeMaterial } from "./PointsNodeMaterial.js";
+export { default as ShadowNodeMaterial } from "./ShadowNodeMaterial.js";
 export { default as SpriteNodeMaterial } from "./SpriteNodeMaterial.js";

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

@@ -0,0 +1,23 @@
+import { MeshNormalMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface MeshBasicNodeMaterialParameters extends NodeMaterialParameters, MeshNormalMaterialParameters {
+}
+
+export default class MeshNormalNodeMaterial extends NodeMaterial {
+    readonly isMeshNormalNodeMaterial: true;
+
+    // Properties from MeshNormalMaterial
+    readonly isMeshNormalMaterial: true;
+    bumpMap: Texture | null;
+    bumpScale: number;
+    normalMap: Texture | null;
+    normalMapType: NormalMapTypes;
+    normalScale: Vector2;
+    displacementMap: Texture | null;
+    displacementScale: number;
+    displacementBias: number;
+    flatShading: boolean;
+
+    constructor(parameters?: MeshBasicNodeMaterialParameters);
+}

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

@@ -23,7 +23,7 @@ export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
     iridescenceIORNode: ShaderNodeObject<Node> | null;
     iridescenceThicknessNode: ShaderNodeObject<Node> | null;
 
-    iorNode?: ShaderNodeObject<Node> | null;
+    iorNode: ShaderNodeObject<Node> | null;
 
     specularIntensityNode: ShaderNodeObject<Node> | null;
     specularColorNode: ShaderNodeObject<Node> | null;
@@ -33,39 +33,49 @@ export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
     attenuationDistanceNode: ShaderNodeObject<Node> | null;
     attenuationColorNode: ShaderNodeObject<Node> | null;
 
+    anisotropyNode: ShaderNodeObject<Node> | null;
+
     // Properties from MeshPhysicalMaterial
     readonly isMeshPhysicalMaterial: true;
-    clearcoat: number;
+    anisotropyRotation: number;
+    anisotropyMap: Texture | null;
     clearcoatMap: Texture | null;
     clearcoatRoughness: number;
     clearcoatRoughnessMap: Texture | null;
     clearcoatNormalScale: Vector2;
     clearcoatNormalMap: Texture | null;
-    reflectivity: number;
     ior: number;
-    sheen: number;
+    get reflectivity(): number;
+    set reflectivity(reflectivity: number);
+    iridescenceMap: Texture | null;
+    iridescenceIOR: number;
+    iridescenceThicknessRange: [number, number];
+    iridescenceThicknessMap: Texture | null;
     sheenColor: Color;
     sheenColorMap: Texture | null;
     sheenRoughness: number;
     sheenRoughnessMap: Texture | null;
-    transmission: number;
     transmissionMap: Texture | null;
     thickness: number;
     thicknessMap: Texture | null;
     attenuationDistance: number;
     attenuationColor: Color;
     specularIntensity: number;
-    specularColor: Color;
     specularIntensityMap: Texture | null;
+    specularColor: Color;
     specularColorMap: Texture | null;
-    iridescenceMap: Texture | null;
-    iridescenceIOR: number;
-    iridescence: number;
-    iridescenceThicknessRange: [number, number];
-    iridescenceThicknessMap: Texture | null;
-    anisotropy?: number;
-    anisotropyRotation?: number;
-    anisotropyMap?: Texture | null;
+    get anisotropy(): number;
+    set anisotropy(value: number);
+    get clearcoat(): number;
+    set clearcoat(value: number);
+    get iridescence(): number;
+    set iridescence(value: number);
+    get dispersion(): number;
+    set dispersion(value: number);
+    get sheen(): number;
+    set sheen(value: number);
+    get transmission(): number;
+    set transmission(value: number);
 
     constructor(parameters?: MeshPhysicalNodeMaterialParameters);
 }

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

@@ -2,12 +2,14 @@ import {
     LineBasicMaterial,
     Material,
     MeshBasicMaterial,
+    MeshNormalMaterial,
     MeshPhongMaterial,
     MeshPhysicalMaterial,
     MeshStandardMaterial,
     PointsMaterial,
     ShaderMaterial,
     ShaderMaterialParameters,
+    ShadowMaterial,
     SpriteMaterial,
 } from "three";
 import ClippingNode from "../accessors/ClippingNode.js";
@@ -18,10 +20,12 @@ import LightsNode from "../lighting/LightsNode.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import LineBasicNodeMaterial from "./LineBasicNodeMaterial.js";
 import MeshBasicNodeMaterial from "./MeshBasicNodeMaterial.js";
+import MeshNormalNodeMaterial from "./MeshNormalNodeMaterial.js";
 import MeshPhongNodeMaterial from "./MeshPhongNodeMaterial.js";
 import MeshPhysicalNodeMaterial from "./MeshPhysicalNodeMaterial.js";
 import MeshStandardNodeMaterial from "./MeshStandardNodeMaterial.js";
 import PointsNodeMaterial from "./PointsNodeMaterial.js";
+import ShadowNodeMaterial from "./ShadowNodeMaterial.js";
 import SpriteNodeMaterial from "./SpriteNodeMaterial.js";
 
 export interface NodeMaterialParameters extends ShaderMaterialParameters {
@@ -31,6 +35,7 @@ export interface NodeMaterialParameters extends ShaderMaterialParameters {
 
     lightsNode?: ShaderNodeObject<LightsNode> | null | undefined;
     envNode?: ShaderNodeObject<Node> | null | undefined;
+    aoNode?: ShaderNodeObject<Node> | null | undefined;
 
     colorNode?: ShaderNodeObject<Node> | null | undefined;
     normalNode?: ShaderNodeObject<Node> | null | undefined;
@@ -55,10 +60,9 @@ export default class NodeMaterial extends ShaderMaterial {
 
     normals: boolean;
 
-    colorSpaced: boolean;
-
     lightsNode: ShaderNodeObject<LightsNode> | null;
     envNode: ShaderNodeObject<Node> | null;
+    aoNode: ShaderNodeObject<Node> | null;
 
     colorNode: ShaderNodeObject<Node> | null;
     normalNode: ShaderNodeObject<Node> | null;
@@ -71,6 +75,7 @@ export default class NodeMaterial extends ShaderMaterial {
 
     depthNode: ShaderNodeObject<Node> | null;
     shadowNode: ShaderNodeObject<Node> | null;
+    shadowPositionNode: ShaderNodeObject<Node> | null;
 
     outputNode: ShaderNodeObject<Node> | null;
 
@@ -97,10 +102,12 @@ export default class NodeMaterial extends ShaderMaterial {
 
     static fromMaterial(material: LineBasicMaterial): LineBasicNodeMaterial;
     static fromMaterial(material: MeshBasicMaterial): MeshBasicNodeMaterial;
+    static fromMaterial(material: MeshNormalMaterial): MeshNormalNodeMaterial;
     static fromMaterial(material: MeshPhongMaterial): MeshPhongNodeMaterial;
     static fromMaterial(material: MeshPhysicalMaterial): MeshPhysicalNodeMaterial;
     static fromMaterial(material: MeshStandardMaterial): MeshStandardNodeMaterial;
     static fromMaterial(material: PointsMaterial): PointsNodeMaterial;
+    static fromMaterial(material: ShadowMaterial): ShadowNodeMaterial;
     static fromMaterial(material: SpriteMaterial): SpriteNodeMaterial;
     static fromMaterial(material: NodeMaterial): NodeMaterial;
     static fromMaterial(material: Material): NodeMaterial;

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

@@ -0,0 +1,15 @@
+import { Color, ShadowMaterialParameters } from "three";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface ShadowNodeMaterialParameters extends NodeMaterialParameters, ShadowMaterialParameters {
+}
+
+export default class ShadowNodeMaterial extends NodeMaterial {
+    readonly isShadowNodeMaterial: true;
+
+    // Properties from ShadowMaterial
+    readonly isShadowMaterial: true;
+    color: Color;
+
+    constructor(parameters?: ShadowNodeMaterialParameters);
+}

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

@@ -2,102 +2,106 @@ import Node from "../core/Node.js";
 import MathNode from "../math/MathNode.js";
 import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.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 function mx_aastep(threshold?: NodeRepresentation, value?: NodeRepresentation): ShaderNodeObject<MathNode>;
+export function mx_aastep(threshold: NodeRepresentation, value: NodeRepresentation): ShaderNodeObject<MathNode>;
 
 export function mx_ramplr(
-    valuel?: NodeRepresentation,
-    valuer?: NodeRepresentation,
-    texcoord?: ShaderNodeObject<Node>,
+    valuel: NodeRepresentation,
+    valuer: NodeRepresentation,
+    texcoord?: NodeRepresentation,
 ): ShaderNodeObject<MathNode>;
 export function mx_ramptb(
-    valuet?: NodeRepresentation,
-    valueb?: NodeRepresentation,
-    texcoord?: ShaderNodeObject<Node>,
+    valuet: NodeRepresentation,
+    valueb: NodeRepresentation,
+    texcoord?: NodeRepresentation,
 ): ShaderNodeObject<MathNode>;
 
 export function mx_splitlr(
-    valuel?: NodeRepresentation,
-    valuer?: NodeRepresentation,
-    center?: NodeRepresentation,
-    texcoord?: ShaderNodeObject<Node>,
+    valuel: NodeRepresentation,
+    valuer: NodeRepresentation,
+    center: NodeRepresentation,
+    texcoord?: NodeRepresentation,
 ): ShaderNodeObject<MathNode>;
 export function mx_splittb(
-    valuet?: NodeRepresentation,
-    valueb?: NodeRepresentation,
-    center?: NodeRepresentation,
-    texcoord?: ShaderNodeObject<Node>,
+    valuet: NodeRepresentation,
+    valueb: NodeRepresentation,
+    center: NodeRepresentation,
+    texcoord?: NodeRepresentation,
 ): ShaderNodeObject<MathNode>;
 
 export function mx_transform_uv(
     uv_scale?: NodeRepresentation,
     uv_offset?: NodeRepresentation,
-    uv_geo?: ShaderNodeObject<Node>,
+    uv_geo?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
 
-export function mx_noise_float(
-    texcoord?: ShaderNodeObject<Node>,
-    amplitude?: NodeRepresentation,
+export function mx_safepower(in1: NodeRepresentation, in2?: NodeRepresentation): ShaderNodeObject<Node>;
+
+export function mx_contrast(
+    input: NodeRepresentation,
+    amount?: NodeRepresentation,
     pivot?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
-export function mx_noise_vec2(
-    texcoord?: ShaderNodeObject<Node>,
+
+export function mx_noise_float(
+    texcoord?: NodeRepresentation,
     amplitude?: NodeRepresentation,
     pivot?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
 export function mx_noise_vec3(
-    texcoord?: ShaderNodeObject<Node>,
+    texcoord?: NodeRepresentation,
     amplitude?: NodeRepresentation,
     pivot?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
 export function mx_noise_vec4(
-    texcoord?: ShaderNodeObject<Node>,
+    texcoord?: NodeRepresentation,
     amplitude?: NodeRepresentation,
     pivot?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
 
 export function mx_worley_noise_float(
-    texcoord?: ShaderNodeObject<Node>,
+    texcoord?: NodeRepresentation,
     jitter?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
 export function mx_worley_noise_vec2(
-    texcoord?: ShaderNodeObject<Node>,
+    texcoord?: NodeRepresentation,
     jitter?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
 export function mx_worley_noise_vec3(
-    texcoord?: ShaderNodeObject<Node>,
+    texcoord?: NodeRepresentation,
     jitter?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
 
-export function mx_cell_noise_float(texcoord?: ShaderNodeObject<Node>): ShaderNodeObject<Node>;
+export function mx_cell_noise_float(texcoord?: NodeRepresentation): ShaderNodeObject<Node>;
 
 export function mx_fractal_noise_float(
-    position?: ShaderNodeObject<Node>,
+    position?: NodeRepresentation,
     octaves?: NodeRepresentation,
     lacunarity?: NodeRepresentation,
     diminish?: NodeRepresentation,
     amplitude?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
 export function mx_fractal_noise_vec2(
-    position?: ShaderNodeObject<Node>,
+    position?: NodeRepresentation,
     octaves?: NodeRepresentation,
     lacunarity?: NodeRepresentation,
     diminish?: NodeRepresentation,
     amplitude?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
 export function mx_fractal_noise_vec3(
-    position?: ShaderNodeObject<Node>,
+    position?: NodeRepresentation,
     octaves?: NodeRepresentation,
     lacunarity?: NodeRepresentation,
     diminish?: NodeRepresentation,
     amplitude?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
 export function mx_fractal_noise_vec4(
-    position?: ShaderNodeObject<Node>,
+    position?: NodeRepresentation,
     octaves?: NodeRepresentation,
     lacunarity?: NodeRepresentation,
     diminish?: NodeRepresentation,
     amplitude?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
 
-export { mx_hsvtorgb, mx_rgbtohsv };
+export { mx_hsvtorgb, mx_rgbtohsv, mx_srgb_texture_to_lin_rec709 };

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

@@ -1,6 +1,5 @@
-import { Fn } from "../../code/FunctionNode.js";
 import Node from "../../core/Node.js";
-import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../../shadernode/ShaderNode.js";
 
-export function mx_hsvtorgb(...params: Fn<[Node]>): ShaderNodeObject<Node>;
-export function mx_rgbtohsv(...params: Fn<[Node]>): ShaderNodeObject<Node>;
+export const mx_hsvtorgb: (hsv_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+export const mx_rgbtohsv: (c_immutable: NodeRepresentation) => ShaderNodeObject<Node>;