@types/three 0.160.0 → 0.161.1

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

@@ -0,0 +1,32 @@
+import { Vector2 } from "../../../../src/Three.js";
+import TextureNode from "../accessors/TextureNode.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class AnamorphicNode extends TempNode {
+    textureNode: TextureNode;
+    thresholdNode: Node;
+    scaleNode: Node;
+    samples: number;
+    resolution: Vector2;
+
+    constructor(textureNode: TextureNode, thresholdNode: Node, scaleNode: Node, samples: number);
+
+    getTextureNode(): TextureNode;
+
+    setSize(width: number, height: number): void;
+}
+
+export const anamorphic: (
+    node: TextureNode,
+    threshold?: NodeRepresentation,
+    scale?: NodeRepresentation,
+    samples?: NodeRepresentation,
+) => ShaderNodeObject<AnamorphicNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        anamorphic: typeof anamorphic;
+    }
+}

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

@@ -1,14 +1,15 @@
-import TempNode from '../core/TempNode.js';
-import Node from '../core/Node.js';
-import { NodeRepresentation, ShaderNode, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { JoinNode } from "../Nodes.js";
+import { NodeRepresentation, ShaderNode, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
-export const BurnNode: ShaderNode<{ base: Node; blendNode: Node }>;
+export const BurnNode: (args: { base: Node; blend: Node }) => ShaderNodeObject<JoinNode>;
 
-export const DodgeNode: ShaderNode<{ base: Node; blendNode: Node }>;
+export const DodgeNode: (args: { base: Node; blend: Node }) => ShaderNodeObject<JoinNode>;
 
-export const ScreenNode: ShaderNode<{ base: Node; blendNode: Node }>;
+export const ScreenNode: (args: { base: Node; blend: Node }) => ShaderNodeObject<JoinNode>;
 
-export const OverlayNode: ShaderNode<{ base: Node; blendNode: Node }>;
+export const OverlayNode: (args: { base: Node; blend: Node }) => ShaderNodeObject<JoinNode>;
 
 export type BlendMode =
     | typeof BlendModeNode.BURN
@@ -17,10 +18,10 @@ export type BlendMode =
     | typeof BlendModeNode.OVERLAY;
 
 export default class BlendModeNode extends TempNode {
-    static BURN: 'burn';
-    static DODGE: 'dodge';
-    static SCREEN: 'screen';
-    static OVERLAY: 'overlay';
+    static BURN: "burn";
+    static DODGE: "dodge";
+    static SCREEN: "screen";
+    static OVERLAY: "overlay";
 
     baseNode: Node;
     blendMode: BlendMode;
@@ -35,3 +36,12 @@ export const burn: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation
 export const dodge: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
 export const overlay: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
 export const screen: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        burn: typeof burn;
+        dodge: typeof dodge;
+        overlay: typeof overlay;
+        screen: typeof screen;
+    }
+}

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

@@ -1,6 +1,6 @@
-import TempNode from '../core/TempNode.js';
-import MathNode from '../math/MathNode.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import TempNode from "../core/TempNode.js";
+import MathNode from "../math/MathNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export type ColorAdjustmentMethod =
     | typeof ColorAdjustmentNode.SATURATION
@@ -8,9 +8,9 @@ export type ColorAdjustmentMethod =
     | typeof ColorAdjustmentNode.HUE;
 
 export default class ColorAdjustmentNode extends TempNode {
-    static SATURATION: 'saturation';
-    static VIBRANCE: 'vibrance';
-    static HUE: 'hue';
+    static SATURATION: "saturation";
+    static VIBRANCE: "vibrance";
+    static HUE: "hue";
 
     method: ColorAdjustmentMethod;
 
@@ -35,3 +35,14 @@ export const hue: (
 
 export const lumaCoeffs: ShaderNodeObject<MathNode>;
 export const luminance: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<MathNode>;
+
+export const threshold: (color: NodeRepresentation, thershold: NodeRepresentation) => ShaderNodeObject<MathNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        saturation: typeof saturation;
+        vibrance: typeof vibrance;
+        hue: typeof hue;
+        threshold: typeof threshold;
+    }
+}

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

@@ -1,7 +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';
+import { ColorSpace } from "../../../../src/Three.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export type ColorSpaceNodeMethod =
     | typeof ColorSpaceNode.LINEAR_TO_LINEAR
@@ -9,9 +9,9 @@ export type ColorSpaceNodeMethod =
     | typeof ColorSpaceNode.sRGB_TO_LINEAR;
 
 export default class ColorSpaceNode extends TempNode {
-    static LINEAR_TO_LINEAR: 'LinearToLinear';
-    static LINEAR_TO_sRGB: 'LinearTosRGB';
-    static sRGB_TO_LINEAR: 'sRGBToLinear';
+    static LINEAR_TO_LINEAR: "LinearToLinear";
+    static LINEAR_TO_sRGB: "LinearTosRGB";
+    static sRGB_TO_LINEAR: "sRGBToLinear";
 
     method: ColorSpaceNodeMethod;
     node: Node;
@@ -19,4 +19,17 @@ export default class ColorSpaceNode extends TempNode {
     constructor(method: ColorSpaceNodeMethod | null, node: Node);
 }
 
-export const colorSpace: (node: NodeRepresentation, encoding: TextureEncoding) => ShaderNodeObject<ColorSpaceNode>;
+export const linearToColorSpace: (node: NodeRepresentation, colorSpace: ColorSpace) => ShaderNodeObject<ColorSpaceNode>;
+export const colorSpaceToLinear: (node: NodeRepresentation, colorSpace: ColorSpace) => ShaderNodeObject<ColorSpaceNode>;
+
+export const linearTosRGB: (node: NodeRepresentation) => ShaderNodeObject<ColorSpaceNode>;
+export const sRGBToLinear: (node: NodeRepresentation) => ShaderNodeObject<ColorSpaceNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        linearTosRGB: typeof linearTosRGB;
+        sRGBToLinear: typeof sRGBToLinear;
+        linearToColorSpace: typeof linearToColorSpace;
+        colorSpaceToLinear: typeof colorSpaceToLinear;
+    }
+}

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

@@ -1,5 +1,5 @@
-import Node from '../core/Node.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class FrontFacingNode extends Node {
     isFrontFacingNode: true;

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

@@ -0,0 +1,28 @@
+import { Vector2 } from "../../../../src/Three.js";
+import TextureNode from "../accessors/TextureNode.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class GaussianBlurNode extends TempNode {
+    textureNode: TextureNode;
+    sigma: number;
+
+    directionNode: Node;
+
+    resolution: Vector2;
+
+    constructor(textureNode: TextureNode, sigma?: number);
+
+    setSize(width: number, height: number): void;
+
+    getTextureNode(): TextureNode;
+}
+
+export const gaussianBlur: (node: NodeRepresentation, sigma?: number) => ShaderNodeObject<GaussianBlurNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        gaussianBlur: typeof gaussianBlur;
+    }
+}

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

@@ -1,8 +1,8 @@
-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';
+import { NormalMapTypes } from "../../../../src/Three.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import MathNode from "../math/MathNode.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class NormalMapNode extends TempNode {
     node: Node;
@@ -16,3 +16,9 @@ export default class NormalMapNode extends TempNode {
 export const normalMap: (node: Node, scaleNode?: Node) => ShaderNodeObject<NormalMapNode>;
 
 export const TBNViewMatrix: ShaderNodeObject<MathNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        normalMap: typeof normalMap;
+    }
+}

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

@@ -0,0 +1,44 @@
+import { Camera, RenderTarget, Scene, Texture } from "../../../../src/Three.js";
+import TextureNode from "../accessors/TextureNode.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+declare class PassTextureNode extends TextureNode {
+    passNode: PassNode;
+
+    constructor(passNode: PassNode, texture: Texture);
+}
+
+export default class PassNode extends TempNode {
+    scope: PassNodeScope;
+    scene: Scene;
+    camera: Camera;
+
+    renderTarget: RenderTarget;
+
+    readonly isPassNode: true;
+
+    constructor(scope: PassNodeScope, scene: Scene, camera: Camera);
+
+    getTextureNode(): ShaderNodeObject<PassTextureNode>;
+
+    getTextureDepthNode(): ShaderNodeObject<PassTextureNode>;
+
+    getDepthNode(): ShaderNodeObject<Node>;
+
+    setSize(width: number, height: number): void;
+
+    setPixelRatio(pixelRatio: number): void;
+
+    dispose(): void;
+
+    static COLOR: "color";
+    static DEPTH: "depth";
+}
+
+export type PassNodeScope = typeof PassNode.COLOR | typeof PassNode.DEPTH;
+
+export const pass: (scene: Scene, camera: Camera) => ShaderNodeObject<PassNode>;
+export const texturePass: (pass: PassNode, texture: Texture) => ShaderNodeObject<PassTextureNode>;
+export const depthPass: (scene: Scene, camera: Camera) => ShaderNodeObject<PassNode>;

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

@@ -1,5 +1,5 @@
-import Node from '../core/Node.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class PosterizeNode extends Node {
     sourceNode: Node;
@@ -12,3 +12,9 @@ export const posterize: (
     sourceNode: NodeRepresentation,
     stepsNode: NodeRepresentation,
 ) => ShaderNodeObject<PosterizeNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        posterize: typeof posterize;
+    }
+}

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

@@ -1,7 +1,7 @@
-import { ToneMapping } from '../../../../src/Three.js';
-import TempNode from '../core/TempNode.js';
-import Node from '../core/Node.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { ToneMapping } from "../../../../src/Three.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 // exposure only
 export const LinearToneMappingNode: Node;

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

@@ -0,0 +1,32 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class ViewportDepthNode extends Node {
+    scope: ViewportDepthNodeScope;
+    valueNode: Node;
+
+    readonly isViewportDepthNode: true;
+
+    constructor(scope: ViewportDepthNodeScope, valueNode?: Node | null);
+
+    static DEPTH: "depth";
+    static DEPTH_TEXTURE: "depthTexture";
+    static DEPTH_PIXEL: "depthPixel";
+}
+
+export type ViewportDepthNodeScope =
+    | typeof ViewportDepthNode.DEPTH
+    | typeof ViewportDepthNode.DEPTH_TEXTURE
+    | typeof ViewportDepthNode.DEPTH_PIXEL;
+
+export const viewZToOrthographicDepth: (viewZ: Node, near: Node, far: Node) => Node;
+
+export const orthographicDepthToViewZ: (depth: Node, near: Node, far: Node) => Node;
+
+export const viewZToPerspectiveDepth: (viewZ: Node, near: Node, far: Node) => Node;
+
+export const perspectiveDepthToViewZ: (depth: Node, near: Node, far: Node) => Node;
+
+export const depth: ShaderNodeObject<ViewportDepthNode>;
+export const depthTexture: (valueNode?: Node | null) => ShaderNodeObject<ViewportDepthNode>;
+export const depthPixel: ShaderNodeObject<ViewportDepthNode>;

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

@@ -1,5 +1,5 @@
-import Node from '../core/Node.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export type ViewportNodeScope =
     | typeof ViewportNode.COORDINATE
@@ -10,12 +10,12 @@ export type ViewportNodeScope =
     | typeof ViewportNode.BOTTOM_RIGHT;
 
 export default class ViewportNode extends Node {
-    static COORDINATE: 'coordinate';
-    static RESOLUTION: 'resolution';
-    static TOP_LEFT: 'topLeft';
-    static BOTTOM_LEFT: 'bottomLeft';
-    static TOP_RIGHT: 'topRight';
-    static BOTTOM_RIGHT: 'bottomRight';
+    static COORDINATE: "coordinate";
+    static RESOLUTION: "resolution";
+    static TOP_LEFT: "topLeft";
+    static BOTTOM_LEFT: "bottomLeft";
+    static TOP_RIGHT: "topRight";
+    static BOTTOM_RIGHT: "bottomRight";
 
     scope: ViewportNodeScope;
     isViewportNode: true;

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

@@ -0,0 +1,18 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import ViewportTextureNode from "./ViewportTextureNode.js";
+
+export default class ViewportSharedTextureNode extends ViewportTextureNode {
+    constructor(uvNode?: Node, levelNode?: Node | null);
+}
+
+export const viewportSharedTexture: (
+    uvNode?: Node,
+    levelNode?: Node | null,
+) => ShaderNodeObject<ViewportSharedTextureNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        viewportSharedTexture: typeof viewportSharedTexture;
+    }
+}

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

@@ -0,0 +1,33 @@
+import { FramebufferTexture } from "../../../../src/Three.js";
+import TextureNode from "../accessors/TextureNode.js";
+import { NodeUpdateType } from "../core/constants.js";
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class ViewportTextureNode extends TextureNode {
+    generateMipmaps: boolean;
+
+    readonly isOutputTextureNode: true;
+
+    updateBeforeType: NodeUpdateType;
+
+    constructor(uvNode?: Node, levelNode?: Node | null, framebufferTexture?: FramebufferTexture | null);
+}
+
+export const viewportTexture: (
+    uvNode?: Node,
+    levelNode?: Node | null,
+    framebufferTexture?: FramebufferTexture | null,
+) => ShaderNodeObject<ViewportTextureNode>;
+export const viewportMipTexture: (
+    uvNode?: Node,
+    levelNode?: Node | null,
+    framebufferTexture?: FramebufferTexture | null,
+) => ShaderNodeObject<Node>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        viewportTexture: typeof viewportTexture;
+        viewportMipTexture: typeof viewportMipTexture;
+    }
+}

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

@@ -1,6 +1,6 @@
-import Node from '../core/Node.js';
-import FogNode from './FogNode.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import FogNode from "./FogNode.js";
 
 export default class FogExp2Node extends FogNode {
     isFogExp2Node: true;
@@ -10,3 +10,9 @@ export default class FogExp2Node extends FogNode {
 }
 
 export const densityFog: (colorNode: Node, densityNode: Node) => ShaderNodeObject<FogExp2Node>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        densityFog: typeof densityFog;
+    }
+}

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

@@ -1,5 +1,5 @@
-import Node from '../core/Node.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class FogNode extends Node {
     isFogNode: true;
@@ -11,3 +11,9 @@ export default class FogNode extends Node {
 }
 
 export const fog: (colorNode: NodeRepresentation, factorNode: NodeRepresentation) => ShaderNodeObject<FogNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        fog: typeof fog;
+    }
+}

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

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

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

@@ -1,6 +1,13 @@
-import { ShaderNode } from '../../shadernode/ShaderNode.js';
-import Node from '../../core/Node.js';
+import Node from "../../core/Node.js";
+import OperatorNode from "../../math/OperatorNode.js";
+import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
 
-declare const BRDF_GGX: ShaderNode<{ lightDirection: Node; f0: Node; f90: Node; roughness: Node }>;
+declare const BRDF_GGX: (args: {
+    lightDirection: Node;
+    f0: Node;
+    f90: Node;
+    roughness: Node;
+    iridescenceFresnel?: Node;
+}) => ShaderNodeObject<OperatorNode>;
 
 export default BRDF_GGX;

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

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

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

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

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

@@ -1,10 +1,11 @@
-import { ShaderNode } from '../../shadernode/ShaderNode.js';
-import Node from '../../core/Node.js';
+import Node from "../../core/Node.js";
+import OperatorNode from "../../math/OperatorNode.js";
+import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
 
 // Analytical approximation of the DFG LUT, one half of the
 // split-sum approximation used in indirect specular lighting.
 // via 'environmentBRDF' from "Physically Based Shading on Mobile"
 // https://www.unrealengine.com/blog/physically-based-shading-on-mobile
-declare const DFGApprox: ShaderNode<{ roughness: Node }>;
+declare const DFGApprox: (args: { roughness: Node; dotNV: Node }) => ShaderNodeObject<OperatorNode>;
 
 export default DFGApprox;

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

@@ -1,9 +1,10 @@
-import { ShaderNode } from '../../shadernode/ShaderNode.js';
-import Node from '../../core/Node.js';
+import Node from "../../core/Node.js";
+import OperatorNode from "../../math/OperatorNode.js";
+import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
 
 // Microfacet Models for Refraction through Rough Surfaces - equation (33)
 // http://graphicrants.blogspot.com/2013/08/specular-brdf-reference.html
 // alpha is "roughness squared" in Disney’s reparameterization
-declare const D_GGX: ShaderNode<{ alpha: Node; dotNH: Node }>;
+declare const D_GGX: (args: { alpha: Node; dotNH: Node }) => ShaderNodeObject<OperatorNode>;
 
 export default D_GGX;

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

@@ -1,6 +1,7 @@
-import { ShaderNode } from '../../shadernode/ShaderNode.js';
-import Node from '../../core/Node.js';
+import Node from "../../core/Node.js";
+import OperatorNode from "../../math/OperatorNode.js";
+import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
 
-declare const F_Schlick: ShaderNode<{ f0: Node; f90: Node; dotVH: Node }>;
+declare const F_Schlick: (args: { f0: Node; f90: Node; dotVH: Node }) => ShaderNodeObject<OperatorNode>;
 
 export default F_Schlick;

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

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

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

@@ -0,0 +1,7 @@
+import LightingModel from "../core/LightingModel.js";
+
+export default class PhongLightingModel extends LightingModel {
+    specular: boolean;
+
+    constructor(specular?: boolean);
+}

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

@@ -1,11 +1,20 @@
-import { ShaderNode } from '../shadernode/ShaderNode.js';
-import Node from '../core/Node.js';
+import LightingModel from "../core/LightingModel.js";
+import Node from "../core/Node.js";
 
-declare const PhysicalLightingModel: {
-    direct: ShaderNode<{ lightDirection: Node; lightColor: Node; reflectedLight: Node }>;
-    indirectDiffuse: ShaderNode<{ irradiance: Node; reflectedLight: Node }>;
-    indirectSpecular: ShaderNode<{ radiance: Node; iblIrradiance: Node; reflectedLight: Node }>;
-    ambientOcclusion: ShaderNode<{ ambientOcclusion: Node; reflectedLight: Node }>;
-};
+export default class PhysicalLightingModel extends LightingModel {
+    clearcoat: boolean;
+    sheen: boolean;
+    iridescence: boolean;
 
-export default PhysicalLightingModel;
+    clearcoatRadiance: Node | null;
+    clearcoatSpecularDirect: Node | null;
+    clearcoatSpecularIndirect: Node | null;
+    sheenSpecularDirect: Node | null;
+    sheenSpecularIndirect: Node | null;
+    iridescenceFresnel: Node | null;
+    iridescenceF0: Node | null;
+
+    constructor(clearcoat?: boolean, sheen?: boolean, iridescence?: boolean);
+
+    computeMultiscattering(singleScatter: Node, multiScatter: Node, specularF90?: Node): void;
+}

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

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

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

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

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

@@ -1,7 +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';
+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;