@types/three 0.170.0 → 0.172.0

three/src/nodes/core/NodeUtils.d.ts

@@ -17,8 +17,15 @@ export const hashArray: (array: number[]) => number;
 export const hash: (...params: number[]) => number;
 
 export function getCacheKey(object: Node, force?: boolean): number;
+
 export function getNodeChildren(object: Node): Generator<NodeChild, void>;
+
+export function getTypeFromLength(length: number): string | undefined;
+
+export function getLengthFromType(type: string): number | undefined;
+
 export function getValueType(value: unknown): string | null;
+
 export function getValueFromType(
     type: string,
     ...params: number[]

three/src/nodes/core/NodeVar.d.ts

@@ -1,7 +1,19 @@
+/**
+ * {@link NodeBuilder} is going to create instances of this class during the build process
+ * of nodes. They represent the final shader variables that are going to be generated
+ * by the builder. A dictionary of node variables is maintained in {@link NodeBuilder#vars} for
+ * this purpose.
+ */
 declare class NodeVar {
     readonly isNodeVar: true;
     name: string;
     type: string | null;
+    /**
+     * Constructs a new node variable.
+     *
+     * @param {String} name - The name of the variable.
+     * @param {String} type - The type of the variable.
+     */
     constructor(name: string, type: string | null);
 }
 export default NodeVar;

three/src/nodes/core/NodeVarying.d.ts

@@ -1,7 +1,21 @@
 import NodeVar from "./NodeVar.js";
+/**
+ * {@link NodeBuilder} is going to create instances of this class during the build process
+ * of nodes. They represent the final shader varyings that are going to be generated
+ * by the builder. An array of node varyings is maintained in {@link NodeBuilder#varyings} for
+ * this purpose.
+ *
+ * @augments NodeVar
+ */
 declare class NodeVarying extends NodeVar {
     needsInterpolation: boolean;
     readonly isNodeVarying: true;
+    /**
+     * Constructs a new node varying.
+     *
+     * @param {String} name - The name of the varying.
+     * @param {String} type - The type of the varying.
+     */
     constructor(name: string, type: string | null);
 }
 export default NodeVarying;

three/src/nodes/core/StackNode.d.ts

@@ -1,6 +1,7 @@
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
-export default class StackNode extends Node {
+declare class StackNode extends Node {
     isStackNode: true;
     nodes: Node[];
     outputNode: Node | null;
@@ -25,3 +26,7 @@ export default class StackNode extends Node {
      */
     else(method: () => void): this;
 }
+
+export default StackNode;
+
+export const stack: () => ShaderNodeObject<StackNode>;

three/src/nodes/core/StructTypeNode.d.ts

@@ -1,9 +1,27 @@
 import Node from "./Node.js";
+/**
+ * {@link NodeBuilder} is going to create instances of this class during the build process
+ * of nodes. They represent the final shader struct data that are going to be generated
+ * by the builder. A dictionary of struct types is maintained in {@link NodeBuilder#structs}
+ * for this purpose.
+ */
 declare class StructTypeNode extends Node {
     static get type(): string;
+    name: string;
     types: string[];
     readonly isStructTypeNode: true;
-    constructor(types: string[]);
+    /**
+     * Constructs a new struct type node.
+     *
+     * @param {String} name - The name of the struct.
+     * @param {Array<String>} types - An array of types.
+     */
+    constructor(name: string, types: string[]);
+    /**
+     * Returns the member types.
+     *
+     * @return {Array<String>} The types.
+     */
     getMemberTypes(): string[];
 }
 export default StructTypeNode;

three/src/nodes/core/UniformNode.d.ts

@@ -4,20 +4,64 @@ import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
 import NodeFrame from "./NodeFrame.js";
 import UniformGroupNode from "./UniformGroupNode.js";
+/** @module UniformNode **/
+/**
+ * Class for representing a uniform.
+ *
+ * @augments InputNode
+ */
 declare class UniformNode<TValue> extends InputNode<TValue> {
     static get type(): string;
     readonly isUniformNode: true;
     name: string;
     groupNode: UniformGroupNode;
+    /**
+     * Constructs a new uniform node.
+     *
+     * @param {Any} value - The value of this node. Usually a JS primitive or three.js object (vector, matrix, color, texture).
+     * @param {String?} nodeType - The node type. If no explicit type is defined, the node tries to derive the type from its value.
+     */
     constructor(value: TValue, nodeType?: string | null);
+    /**
+     * Sets the {@link UniformNode#name} property.
+     *
+     * @param {String} name - The name of the uniform.
+     * @return {UniformNode} A reference to this node.
+     */
     label(name: string): this;
+    /**
+     * Sets the {@link UniformNode#groupNode} property.
+     *
+     * @param {UniformGroupNode} group - The uniform group.
+     * @return {UniformNode} A reference to this node.
+     */
     setGroup(group: UniformGroupNode): this;
+    /**
+     * Returns the {@link UniformNode#groupNode}.
+     *
+     * @return {UniformGroupNode} The uniform group.
+     */
     getGroup(): UniformGroupNode;
+    /**
+     * By default, this method returns the result of {@link Node#getHash} but derived
+     * classes might overwrite this method with a different implementation.
+     *
+     * @param {NodeBuilder} builder - The current node builder.
+     * @return {String} The uniform hash.
+     */
     getUniformHash(builder: NodeBuilder): string;
     onUpdate(callback: (frame: NodeFrame, self: this) => TValue | undefined, updateType: NodeUpdateType): this;
     generate(builder: NodeBuilder, output: string | null): string;
 }
 export default UniformNode;
+/**
+ * TSL function for creating a uniform node.
+ *
+ * @function
+ * @param {Any} arg1 - The value of this node. Usually a JS primitive or three.js object (vector, matrix, color, texture).
+ * @param {String?} arg2 - The node type. If no explicit type is defined, the node tries to derive the type from its value.
+ * @returns {UniformNode}
+ */
 export declare const uniform: <TValue>(
     arg1: InputNode<TValue> | TValue,
     arg2?: Node | string,

three/src/nodes/core/VaryingNode.d.ts

@@ -14,8 +14,11 @@ export default class VaryingNode extends Node {
 
 export const varying: (node: NodeRepresentation, name?: string) => ShaderNodeObject<VaryingNode>;
 
+export const vertexStage: (node: NodeRepresentation) => ShaderNodeObject<VaryingNode>;
+
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {
         varying: typeof varying;
+        vertexStage: typeof vertexStage;
     }
 }

three/src/nodes/core/constants.d.ts

@@ -1,13 +1,41 @@
+/** @module NodeConstants **/
+/**
+ * Possible shader stages.
+ *
+ * @property {string} VERTEX The vertex shader stage.
+ * @property {string} FRAGMENT The fragment shader stage.
+ */
 export declare const NodeShaderStage: {
     readonly VERTEX: "vertex";
     readonly FRAGMENT: "fragment";
 };
+/**
+ * Update types of a node.
+ *
+ * @property {string} NONE The update method is not executed.
+ * @property {string} FRAME The update method is executed per frame.
+ * @property {string} RENDER The update method is executed per render. A frame might be produced by multiple render calls so this value allows more detailed updates than FRAME.
+ * @property {string} OBJECT The update method is executed per {@link Object3D} that uses the node for rendering.
+ */
 export declare const NodeUpdateType: {
     readonly NONE: "none";
     readonly FRAME: "frame";
     readonly RENDER: "render";
     readonly OBJECT: "object";
 };
+/**
+ * Data types of a node.
+ *
+ * @property {string} BOOLEAN Boolean type.
+ * @property {string} INTEGER Integer type.
+ * @property {string} FLOAT Float type.
+ * @property {string} VECTOR2 Two-dimensional vector type.
+ * @property {string} VECTOR3 Three-dimensional vector type.
+ * @property {string} VECTOR4 Four-dimensional vector type.
+ * @property {string} MATRIX2 2x2 matrix type.
+ * @property {string} MATRIX3 3x3 matrix type.
+ * @property {string} MATRIX4 4x4 matrix type.
+ */
 export declare const NodeType: {
     readonly BOOLEAN: "bool";
     readonly INTEGER: "int";
@@ -19,8 +47,21 @@ export declare const NodeType: {
     readonly MATRIX3: "mat3";
     readonly MATRIX4: "mat4";
 };
+/**
+ * Access types of a node. These are relevant for compute and storage usage.
+ *
+ * @property {string} READ_ONLY Read-only access
+ * @property {string} WRITE_ONLY Write-only access.
+ * @property {string} READ_WRITE Read and write access.
+ */
+export declare const NodeAccess: {
+    readonly READ_ONLY: "readOnly";
+    readonly WRITE_ONLY: "writeOnly";
+    readonly READ_WRITE: "readWrite";
+};
 export type NodeShaderStage = "vertex" | "fragment" | "compute";
 export type NodeUpdateType = "none" | "frame" | "render" | "object";
+export type NodeAccess = "readOnly" | "writeOnly" | "readWrite";
 export declare const defaultShaderStages: NodeShaderStage[];
 export declare const defaultBuildStages: string[];
 export declare const shaderStages: NodeShaderStage[];

three/src/nodes/display/BlendModes.d.ts

@@ -0,0 +1,32 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const blendBurn: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const blendDodge: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const blendScreen: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const blendOverlay: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const blendColor: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+
+/**
+ * @deprecated
+ */
+export const burn: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+
+/**
+ * @deprecated
+ */
+export const dodge: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+
+/**
+ * @deprecated
+ */
+export const screen: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+
+/**
+ * @deprecated
+ */
+export const overlay: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;

three/src/nodes/display/PassNode.d.ts

@@ -68,4 +68,4 @@ export default PassNode;
 
 export const pass: (scene: Scene, camera: Camera, options?: RenderTargetOptions) => ShaderNodeObject<PassNode>;
 export const passTexture: (pass: PassNode, texture: Texture) => ShaderNodeObject<PassTextureNode>;
-export const depthPass: (scene: Scene, camera: Camera) => ShaderNodeObject<PassNode>;
+export const depthPass: (scene: Scene, camera: Camera, options?: RenderTargetOptions) => ShaderNodeObject<PassNode>;

three/src/nodes/display/ScreenNode.d.ts

@@ -37,6 +37,11 @@ export const viewportUV: ShaderNodeObject<Node>;
 
 // Deprecated
 
+/**
+ * @deprecated "viewportResolution" is deprecated. Use "screenSize" instead.
+ */
+export const viewportResolution: ShaderNodeObject<ScreenNode>;
+
 /**
  * @deprecated "viewportTopLeft" is deprecated. Use "viewportUV" instead.
  */

three/src/nodes/display/ViewportDepthNode.d.ts

@@ -29,7 +29,9 @@ export const viewZToPerspectiveDepth: (viewZ: Node, near: Node, far: Node) => No
 
 export const perspectiveDepthToViewZ: (depth: Node, near: Node, far: Node) => Node;
 
-export const perspectiveDepthToLogarithmicDepth: (perspectiveW: Node, near: Node, far: Node) => Node;
+export const viewZToLogarithmicDepth: (viewZ: Node, near: Node, far: Node) => Node;
+
+export const logarithmicDepthToViewZ: (depth: Node, near: Node, far: Node) => Node;
 
 export const depth: ShaderNodeObject<ViewportDepthNode>;
 export const linearDepth: (valueNode?: Node | null) => ShaderNodeObject<ViewportDepthNode>;

three/src/nodes/fog/Fog.d.ts

@@ -0,0 +1,26 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const rangeFogFactor: (near: NodeRepresentation, far: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const densityFogFactor: (density: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const fog: (color: NodeRepresentation, factor: NodeRepresentation) => ShaderNodeObject<Node>;
+
+/**
+ * @deprecated
+ */
+export function rangeFog(
+    color: NodeRepresentation,
+    near: NodeRepresentation,
+    far: NodeRepresentation,
+): ShaderNodeObject<Node>;
+
+/**
+ * @deprecated
+ */
+export function densityFog(
+    color: NodeRepresentation,
+    near: NodeRepresentation,
+    far: NodeRepresentation,
+): ShaderNodeObject<Node>;

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

@@ -0,0 +1,88 @@
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export type AtomicMethod =
+    | typeof AtomicFunctionNode.ATOMIC_LOAD
+    | typeof AtomicFunctionNode.ATOMIC_STORE
+    | typeof AtomicFunctionNode.ATOMIC_ADD
+    | typeof AtomicFunctionNode.ATOMIC_SUB
+    | typeof AtomicFunctionNode.ATOMIC_MAX
+    | typeof AtomicFunctionNode.ATOMIC_MIN
+    | typeof AtomicFunctionNode.ATOMIC_AND
+    | typeof AtomicFunctionNode.ATOMIC_OR
+    | typeof AtomicFunctionNode.ATOMIC_XOR;
+
+declare class AtomicFunctionNode extends TempNode {
+    method: AtomicMethod;
+    pointerNode: Node;
+    valueNode: Node;
+    storeNode: Node;
+
+    constructor(method: AtomicMethod, pointerNode: Node, valueNode: Node, storeNode?: Node | null);
+
+    static ATOMIC_LOAD: "atomicLoad";
+    static ATOMIC_STORE: "atomicStore";
+    static ATOMIC_ADD: "atomicAdd";
+    static ATOMIC_SUB: "atomicSub";
+    static ATOMIC_MAX: "atomicMax";
+    static ATOMIC_MIN: "atomicMin";
+    static ATOMIC_AND: "atomicAnd";
+    static ATOMIC_OR: "atomicOr";
+    static ATOMIC_XOR: "atomicXor";
+}
+
+export const atomicFunc: (
+    method: AtomicMethod,
+    pointerNode: NodeRepresentation,
+    valueNode: NodeRepresentation,
+    storeNode?: NodeRepresentation | null,
+) => ShaderNodeObject<AtomicFunctionNode>;
+
+export const atomicStore: (
+    pointerNode: NodeRepresentation,
+    valueNode: NodeRepresentation,
+    storeNode?: NodeRepresentation | null,
+) => ShaderNodeObject<AtomicFunctionNode>;
+
+export const atomicAdd: (
+    pointerNode: NodeRepresentation,
+    valueNode: NodeRepresentation,
+    storeNode?: NodeRepresentation | null,
+) => ShaderNodeObject<AtomicFunctionNode>;
+
+export const atomicSub: (
+    pointerNode: NodeRepresentation,
+    valueNode: NodeRepresentation,
+    storeNode?: NodeRepresentation | null,
+) => ShaderNodeObject<AtomicFunctionNode>;
+
+export const atomicMax: (
+    pointerNode: NodeRepresentation,
+    valueNode: NodeRepresentation,
+    storeNode?: NodeRepresentation | null,
+) => ShaderNodeObject<AtomicFunctionNode>;
+
+export const atomicMin: (
+    pointerNode: NodeRepresentation,
+    valueNode: NodeRepresentation,
+    storeNode?: NodeRepresentation | null,
+) => ShaderNodeObject<AtomicFunctionNode>;
+
+export const atomicAnd: (
+    pointerNode: NodeRepresentation,
+    valueNode: NodeRepresentation,
+    storeNode?: NodeRepresentation | null,
+) => ShaderNodeObject<AtomicFunctionNode>;
+
+export const atomicOr: (
+    pointerNode: NodeRepresentation,
+    valueNode: NodeRepresentation,
+    storeNode?: NodeRepresentation | null,
+) => ShaderNodeObject<AtomicFunctionNode>;
+
+export const atomicXor: (
+    pointerNode: NodeRepresentation,
+    valueNode: NodeRepresentation,
+    storeNode?: NodeRepresentation | null,
+) => ShaderNodeObject<AtomicFunctionNode>;

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

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

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

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

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

@@ -8,18 +8,23 @@ export default class ComputeNode extends Node {
     count: number;
     workgroupSize: number[];
     dispatchCount: number;
+    name: string;
 
     onInitFunction: ((args: { renderer: Renderer }) => void) | null;
 
     constructor(computeNode: Node, count: number, workgroupSize?: number[]);
 
+    label(name: string): void;
+
+    updateDispatchCount(): void;
+
     onInit(callback: ((args: { renderer: Renderer }) => void) | null): void;
 }
 
 export const compute: (
     node: NodeRepresentation,
     count: number,
-    workgroupSize: number[],
+    workgroupSize?: number[],
 ) => ShaderNodeObject<ComputeNode>;
 
 declare module "../tsl/TSLCore.js" {

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

@@ -0,0 +1,19 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class WorkgroupInfoNode extends Node {
+    bufferType: string;
+    bufferCount: number;
+
+    readonly isWorkgroupInfoNode: true;
+
+    elementType: string;
+
+    scope: string;
+
+    constructor(scope: string, bufferType: string, bufferCount?: number);
+}
+
+export default WorkgroupInfoNode;
+
+export const workgroupArray: (type: string, count?: number) => ShaderNodeObject<WorkgroupInfoNode>;

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

@@ -1,8 +1,19 @@
 import { Light } from "../../lights/Light.js";
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import LightingNode from "./LightingNode.js";
+import ShadowNode from "./ShadowNode.js";
+
+declare module "../../lights/LightShadow.js" {
+    export interface LightShadow {
+        shadowNode?: Node;
+    }
+}
 
 export default class AnalyticLightNode<T extends Light> extends LightingNode {
     light: T | null;
 
     constructor(light?: T | null);
+
+    setupShadowNode(): ShaderNodeObject<ShadowNode>;
 }

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

@@ -2,14 +2,14 @@ import { Light } from "../../lights/Light.js";
 import Node from "../core/Node.js";
 import { NodeBuilder } from "../Nodes.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
-import LightNode from "./LightNode.js";
+import LightingNode from "./LightingNode.js";
 
 declare class LightsNode extends Node {
     constructor();
 
     setupLightsNode(builder: NodeBuilder): void;
 
-    setupLights(builder: NodeBuilder, lightNodes: LightNode[]): void;
+    setupLights(builder: NodeBuilder, lightNodes: LightingNode[]): void;
 
     setLights(lights: Light[]): this;
 

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

@@ -2,6 +2,7 @@ import { PointLight } from "../../lights/PointLight.js";
 import Node from "../core/Node.js";
 import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 import AnalyticLightNode from "./AnalyticLightNode.js";
+import PointShadowNode from "./PointShadowNode.js";
 
 export const directPointLight: (
     color: NodeRepresentation,
@@ -15,6 +16,8 @@ declare class PointLightNode extends AnalyticLightNode<PointLight> {
     decayExponentNode: Node;
 
     constructor(light?: PointLight | null);
+
+    setupShadowNode(): ShaderNodeObject<PointShadowNode>;
 }
 
 export default PointLightNode;

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

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

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

@@ -0,0 +1,15 @@
+import { Light } from "../../lights/Light.js";
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class ShadowBaseNode extends Node {
+    light: Light;
+
+    readonly isShadowBasedNode: true;
+
+    constructor(light: Light);
+}
+
+export const shadowPositionWorld: ShaderNodeObject<Node>;
+
+export default ShadowBaseNode;

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

@@ -1,12 +1,36 @@
 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 { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import ShadowBaseNode from "./ShadowBaseNode.js";
 
-declare class ShadowNode extends Node {
-    constructor(light: Light, shadow: LightShadow);
+export const BasicShadowFilter: (
+    depthTexture: NodeRepresentation,
+    shadowCoord: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const PCFShadowFilter: (
+    depthTexture: NodeRepresentation,
+    shadowCoord: NodeRepresentation,
+    shadow: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const PCFSoftShadowFilter: (
+    depthTexture: NodeRepresentation,
+    shadowCoord: NodeRepresentation,
+    shadow: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const VSMShadowFilter: (
+    depthTexture: NodeRepresentation,
+    shadowCoord: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+declare class ShadowNode extends ShadowBaseNode {
+    constructor(light: Light, shadow: LightShadow | null);
 }
 
 export default ShadowNode;
 
-export const shadow: (light: Light, shadow: LightShadow) => ShaderNodeObject<ShadowNode>;
+export const shadow: (light: Light, shadow?: LightShadow) => ShaderNodeObject<ShadowNode>;
+export const shadows: ShaderNodeObject<Node>;