@types/three 0.164.1 → 0.166.0

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

@@ -1,7 +1,7 @@
-import { BufferGeometry, Material, Object3D, Renderer } from "three";
+import { BufferGeometry, Material, Object3D, Renderer, Texture } from "three";
 import FogNode from "../fog/FogNode.js";
 import LightsNode from "../lighting/LightsNode.js";
-import { AnyObject, NodeShaderStage, NodeTypeOption } from "./constants.js";
+import { NodeShaderStage } from "./constants.js";
 import Node from "./Node.js";
 import NodeAttribute from "./NodeAttribute.js";
 import NodeCache from "./NodeCache.js";
@@ -18,12 +18,12 @@ export interface FlowData {
 }
 
 export interface NodeData {
-    vertex: AnyObject;
-    fragment: AnyObject;
-    compute: AnyObject;
+    vertex: { [key: string]: unknown };
+    fragment: { [key: string]: unknown };
+    compute: { [key: string]: unknown };
 }
 
-export type NodeBuilderContext = AnyObject;
+export type NodeBuilderContext = { [key: string]: unknown };
 
 export default abstract class NodeBuilder {
     object: Object3D;
@@ -58,6 +58,7 @@ export default abstract class NodeBuilder {
     setHashNode(node: Node, hash: string): void;
     addNode(node: Node): void;
     get currentNode(): Node;
+    isFilteredTexture(texture: Texture): boolean;
     getMethod(method: string): string;
     getNodeFromHash(hash: string): Node;
 
@@ -65,6 +66,9 @@ export default abstract class NodeBuilder {
 
     setContext(context: NodeBuilderContext): void;
     getContext(): NodeBuilderContext;
+    setCache(cache: NodeCache): void;
+    getCache(): NodeCache;
+    getCacheFromNode(node: Node, parent?: boolean): NodeCache;
     isAvailable(name: string): boolean;
 
     abstract getInstanceIndex(): string;
@@ -76,35 +80,35 @@ export default abstract class NodeBuilder {
     isFlipY(): boolean;
 
     // @TODO: rename to .generateConst()
-    getConst(type: NodeTypeOption, value?: unknown): Node;
-    getType(type: NodeTypeOption): NodeTypeOption;
+    getConst(type: string, value?: unknown): Node;
+    getType(type: string): string;
 
     generateMethod(method: string): string;
 
-    getAttribute(name: string, type: NodeTypeOption): NodeAttribute;
+    getAttribute(name: string, type: string): NodeAttribute;
 
-    getPropertyName(node: Node, shaderStage: NodeShaderStage): string;
-    isVector(type: NodeTypeOption): boolean;
+    getPropertyName<TValue>(node: NodeVar | NodeUniform<TValue>, shaderStage: NodeShaderStage): string;
+    isVector(type: string): boolean;
 
-    isMatrix(type: NodeTypeOption): boolean;
-    isReference(type: NodeTypeOption): boolean;
-    isShaderStage(shaderStage: NodeShaderStage): boolean;
-    getComponentType(type: NodeTypeOption): NodeTypeOption;
-    getVectorType(type: NodeTypeOption): NodeTypeOption;
-    getTypeFromLength(length: number): NodeTypeOption;
-    getTypeLength(type: NodeTypeOption): number;
-    getVectorFromMatrix(type: NodeTypeOption): NodeTypeOption;
+    isMatrix(type: string): boolean;
+    isReference(type: string): boolean;
+    getElementType(type: string): string | null;
+    getComponentType(type: string): string | null;
+    getVectorType(type: string): string;
+    getTypeFromLength(length: number): string;
+    getTypeLength(type: string): number;
+    getVectorFromMatrix(type: string): string;
     getDataFromNode(node: Node, shaderStage?: NodeShaderStage): NodeData;
-    getNodeProperties(node: Node, shaderStage?: NodeShaderStage): AnyObject;
+    getNodeProperties(node: Node, shaderStage?: NodeShaderStage): { [key: string]: unknown };
     getUniformFromNode(
         node: Node,
-        type: NodeTypeOption,
+        type: string,
         shaderStage?: NodeShaderStage,
         name?: string | null,
     ): NodeUniform<string>;
-    getVarFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStage): NodeVar;
-    getVaryFromNode(node: Node, type: NodeTypeOption): NodeVarying;
-    getCodeFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStage): string;
+    getVarFromNode(node: Node, type: string, shaderStage?: NodeShaderStage): NodeVar;
+    getVaryFromNode(node: Node, type: string): NodeVarying;
+    getCodeFromNode(node: Node, type: string, shaderStage?: NodeShaderStage): string;
     addFlowCode(code: string): void;
     getFlowData(node: Node, shaderStage: NodeShaderStage): FlowData;
     flowNode(node: Node): FlowData;
@@ -117,7 +121,7 @@ export default abstract class NodeBuilder {
     ): FlowData;
     hasGeometryAttribute(name: string): boolean;
     abstract getAttributes(shaderStage: NodeShaderStage): string;
-    abstract getVarys(shaderStage: NodeShaderStage): string;
+    abstract getVaryings(shaderStage: NodeShaderStage): string;
     getVars(shaderStage: NodeShaderStage): string;
     abstract getUniforms(stage: NodeShaderStage): string;
     getCodes(shaderStage: NodeShaderStage): string;
@@ -128,6 +132,6 @@ export default abstract class NodeBuilder {
     getBuildStage(): BuildStageOption;
     abstract buildCode(): void;
     build(): this;
-    format(snippet: string, fromType: NodeTypeOption, toType: NodeTypeOption): string;
+    format(snippet: string, fromType: string, toType: string): string;
     getSignature(): string;
 }

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

@@ -1,9 +1,51 @@
+import { BufferAttribute, InterleavedBuffer, TypedArray } from "three";
+import BufferAttributeNode from "../accessors/BufferAttributeNode.js";
 import Node from "./Node.js";
-import { NodeData } from "./NodeBuilder.js";
-
-export default class NodeCache {
+import NodeAttribute from "./NodeAttribute.js";
+import NodeCode from "./NodeCode.js";
+import NodeUniform from "./NodeUniform.js";
+import NodeVar from "./NodeVar.js";
+import NodeVarying from "./NodeVarying.js";
+export interface ShaderStageNodeData {
+    properties?:
+        | (
+            & {
+                outputNode: Node | null;
+                initialized?: boolean | undefined;
+            }
+            & {
+                [K in `node${string}`]?: Node | undefined;
+            }
+        )
+        | undefined;
+    bufferAttribute?: NodeAttribute | undefined;
+    structType?: Node | undefined;
+    uniform?: NodeUniform<unknown> | undefined;
+    variable?: NodeVar | undefined;
+    varying?: NodeVarying | undefined;
+    code?: NodeCode | undefined;
+    usageCount?: number | undefined;
+    snippet?: string | undefined;
+    propertyName?: string | undefined;
+    propertySizeName?: string | undefined;
+}
+interface NodeData {
+    vertex?: ShaderStageNodeData | undefined;
+    fragment?: ShaderStageNodeData | undefined;
+    compute?: ShaderStageNodeData | undefined;
+    any?: ShaderStageNodeData | undefined;
+}
+interface BufferAttributeData {
+    node: BufferAttributeNode;
+}
+declare class NodeCache {
     id: number;
-    nodesData: WeakMap<Node, NodeData>;
-
-    constructor();
+    nodesData: WeakMap<Node | TypedArray | InterleavedBuffer | BufferAttribute, NodeData | BufferAttributeData>;
+    parent: NodeCache | null;
+    constructor(parent?: NodeCache | null);
+    getData(node: Node): NodeData | undefined;
+    getData(node: TypedArray | InterleavedBuffer | BufferAttribute): BufferAttributeData | undefined;
+    setData(node: Node, data: NodeData): void;
+    setData(node: TypedArray | InterleavedBuffer | BufferAttribute, data: BufferAttributeData): void;
 }
+export default NodeCache;

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

@@ -5,9 +5,9 @@ export default abstract class NodeFunction {
     type: string;
     inputs: NodeFunctionInput[];
     name: string;
-    presicion: string;
+    precision: string;
 
-    constructor(type: string, inputs: NodeFunctionInput[], name?: string, presicion?: string);
+    constructor(type: string, inputs: NodeFunctionInput[], name?: string, precision?: string);
 
     abstract getCode(name?: string): string;
 }

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

@@ -1,14 +1,17 @@
 import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
-
-export default class NodeKeywords {
+declare class NodeKeywords {
     keywords: string[];
-    nodes: Node[];
-    keywordsCallback: { [name: string]: (name: string) => Node };
-
+    nodes: {
+        [name: string]: Node;
+    };
+    keywordsCallback: {
+        [name: string]: (name: string) => Node;
+    };
+    constructor();
     getNode(name: string): Node;
-    addKeyword(name: string, callback: (name: string) => Node): void;
-
+    addKeyword(name: string, callback: (name: string) => Node): this;
     parse(code: string): Node[];
     include(builder: NodeBuilder, code: string): void;
 }
+export default NodeKeywords;

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

@@ -1,5 +1,5 @@
-import Node from "./Node.js";
-
-export default abstract class NodeParser {
-    abstract parseFunction(source: string): Node;
+import NodeFunction from "./NodeFunction.js";
+declare abstract class NodeParser {
+    abstract parseFunction(source: string): NodeFunction;
 }
+export default NodeParser;

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

@@ -1,17 +1,14 @@
 import UniformNode from "./UniformNode.js";
-
-export default class NodeUniform<Value> {
+declare class NodeUniform<TValue> {
     readonly isNodeUniform: true;
-
     name: string;
-    type: string;
-    node: UniformNode<Value>;
+    type: string | null;
+    node: UniformNode<TValue>;
     needsUpdate: boolean | undefined;
-
-    constructor(name: string, type: string, node: UniformNode<Value>, needsUpdate?: boolean);
-
-    get(): Value;
-    set value(val: Value);
-
+    constructor(name: string, type: string | null, node: UniformNode<TValue>);
+    get value(): TValue;
+    set value(val: TValue);
     get id(): number;
+    get groupNode(): import("./UniformGroupNode.js").default;
 }
+export default NodeUniform;

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

@@ -1,6 +1,7 @@
-export default class NodeVar {
-    isNodeVar: true;
+declare class NodeVar {
+    readonly isNodeVar: true;
     name: string;
-    type: string;
-    constructor(name: string, type: string);
+    type: string | null;
+    constructor(name: string, type: string | null);
 }
+export default NodeVar;

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

@@ -1,8 +1,7 @@
 import NodeVar from "./NodeVar.js";
-
-export default class NodeVarying extends NodeVar {
-    needsInterpolation: false;
-    isNodeVarying: true;
-
-    constructor(name: string, type: string);
+declare class NodeVarying extends NodeVar {
+    needsInterpolation: boolean;
+    readonly isNodeVarying: true;
+    constructor(name: string, type: string | null);
 }
+export default NodeVarying;

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

@@ -1,5 +1,4 @@
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import { NodeTypeOption } from "./constants.js";
 import Node from "./Node.js";
 
 export default class PropertyNode extends Node {
@@ -8,11 +7,11 @@ export default class PropertyNode extends Node {
 
     readonly isPropertyNode: true;
 
-    constructor(nodeType?: NodeTypeOption | null, name?: string | null, varying?: boolean);
+    constructor(nodeType?: string | null, name?: string | null, varying?: boolean);
 }
 
-export const property: (type?: NodeTypeOption | null, name?: string | null) => ShaderNodeObject<PropertyNode>;
-export const varyingProperty: (type?: NodeTypeOption | null, name?: string | null) => ShaderNodeObject<PropertyNode>;
+export const property: (type?: string | null, name?: string | null) => ShaderNodeObject<PropertyNode>;
+export const varyingProperty: (type?: string | null, name?: string | null) => ShaderNodeObject<PropertyNode>;
 
 export const diffuseColor: ShaderNodeObject<PropertyNode>;
 export const roughness: ShaderNodeObject<PropertyNode>;
@@ -40,3 +39,4 @@ export const transmission: ShaderNodeObject<PropertyNode>;
 export const thickness: ShaderNodeObject<PropertyNode>;
 export const attenuationDistance: ShaderNodeObject<PropertyNode>;
 export const attenuationColor: ShaderNodeObject<PropertyNode>;
+export const dispersion: ShaderNodeObject<PropertyNode>;

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

@@ -7,5 +7,11 @@ export default class StackNode extends Node {
 
     constructor();
 
-    assign(targetNode: Node, sourceValue: Node): this;
+    add(node: Node): this;
+
+    if(boolNode: Node, method: () => void): this;
+
+    elseIf(node: Node, method: () => void): this;
+
+    else(node: Node, method: () => void): this;
 }

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

@@ -0,0 +1,8 @@
+import Node from "./Node.js";
+declare class StructTypeNode extends Node {
+    types: string[];
+    readonly isStructTypeNode: true;
+    constructor(types: string[]);
+    getMemberTypes(): string[];
+}
+export default StructTypeNode;

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

@@ -1,11 +1,10 @@
-import { NodeTypeOption } from "./constants.js";
 import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
 
 export default class TempNode extends Node {
     isTempNode: true;
 
-    constructor(type: NodeTypeOption | null);
+    constructor(type: string | null);
 
     hasDependencies(builder: NodeBuilder): boolean;
 }

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

@@ -0,0 +1,7 @@
+export default class UniformGroup {
+    name: string;
+
+    readonly isUniformGroup: true;
+
+    constructor(name: string);
+}

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

@@ -0,0 +1,21 @@
+import Node from "./Node.js";
+
+export default class UniformGroupNode extends Node {
+    name: string;
+    version: number;
+
+    shared: boolean;
+
+    readonly isUniformGroup: true;
+
+    constructor(name: string, shared?: boolean);
+
+    set needsUpdate(value: boolean);
+}
+
+export const uniformGroup: (name: string) => UniformGroupNode;
+export const sharedUniformGroup: (name: string) => UniformGroupNode;
+
+export const frameGroup: UniformGroupNode;
+export const renderGroup: UniformGroupNode;
+export const objectGroup: UniformGroupNode;

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

@@ -1,18 +1,23 @@
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import { NodeTypeOption } from "./constants.js";
+import { NodeUpdateType } from "./constants.js";
 import InputNode from "./InputNode.js";
 import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
-
-export default class UniformNode<Value> extends InputNode<Value> {
+import NodeFrame from "./NodeFrame.js";
+import UniformGroupNode from "./UniformGroupNode.js";
+declare class UniformNode<TValue> extends InputNode<TValue> {
     readonly isUniformNode: true;
-
-    constructor(value: Value, nodeType?: NodeTypeOption | null);
-
+    name: string;
+    groupNode: UniformGroupNode;
+    constructor(value: TValue, nodeType?: string | null);
+    label(name: string): this;
+    setGroup(group: UniformGroupNode): this;
+    getGroup(): UniformGroupNode;
     getUniformHash(builder: NodeBuilder): string;
+    onUpdate(callback: (frame: NodeFrame, self: this) => TValue | undefined, updateType: NodeUpdateType): this;
+    generate(builder: NodeBuilder, output: string | null): string;
 }
-
-export const uniform: <Value>(
-    arg1: InputNode<Value> | Value,
+export default UniformNode;
+export declare const uniform: <TValue>(
+    arg1: InputNode<TValue> | TValue,
     arg2?: Node | string,
-) => ShaderNodeObject<UniformNode<Value>>;
+) => import("../shadernode/ShaderNode.js").ShaderNodeObject<UniformNode<TValue>>;

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

@@ -6,6 +6,8 @@ export default class VarNode extends Node {
     node: Node;
     name: string | null;
 
+    readonly isVarNode: true;
+
     constructor(node: Node, name?: string | null);
 
     op(op: OperatorNodeOp, ...params: Node[]): this;

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

@@ -1,11 +1,15 @@
 import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import Node from "./Node.js";
+import NodeBuilder from "./NodeBuilder.js";
+import NodeVarying from "./NodeVarying.js";
 
 export default class VaryingNode extends Node {
     node: Node;
     name: string | null;
 
     constructor(node: Node, name?: string | null);
+
+    setupVarying(builder: NodeBuilder): NodeVarying;
 }
 
 export const varying: (node: NodeRepresentation, name?: string) => ShaderNodeObject<VaryingNode>;

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

@@ -1,79 +1,27 @@
-export enum NodeShaderStage {
-    VERTEX = "vertex",
-    FRAGMENT = "fragment",
-}
-
-export enum NodeUpdateType {
-    NONE = "none",
-    FRAME = "frame",
-    RENDER = "render",
-    OBJECT = "object",
-}
-
-export enum NodeType {
-    BOOLEAN = "bool",
-    INTEGER = "int",
-    FLOAT = "float",
-    VECTOR2 = "vec2",
-    VECTOR3 = "vec3",
-    VECTOR4 = "vec4",
-    MATRIX2 = "mat2",
-    MATRIX3 = "mat3",
-    MATRIX4 = "mat4",
-}
-
-export type NodeTypeOption =
-    | "bool"
-    | "int"
-    | "float"
-    | "vec2"
-    | "vec3"
-    | "vec4"
-    | "mat2"
-    | "mat3"
-    | "mat4"
-    | "code" /* CodeNode */
-    | "color" /* NodeUtis.getValueType */
-    | "uint"
-    | "int" /* NodeBuilder.getComponentType */
-    | "void"
-    | "property"
-    | "sampler"
-    | "texture"
-    | "cubeTexture" /* NodeBuilder.isReference */
-    | "ivec2"
-    | "uvec2"
-    | "bvec2" /* ShaderNodeBaseElements */
-    | "ivec3"
-    | "uvec3"
-    | "bvec3"
-    | "ivec4"
-    | "uvec4"
-    | "bvec4"
-    | "imat3"
-    | "umat3"
-    | "bmat3"
-    | "imat4"
-    | "umat4"
-    | "bmat4";
-
-export type SwizzleCharacter = "x" | "y" | "z" | "w" | "r" | "g" | "b" | "a" | "s" | "t" | "p" | "q";
-
-export type SwizzleOption = Exclude<
-    | `${SwizzleCharacter}`
-    | `${SwizzleCharacter}${SwizzleCharacter}`
-    | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}`
-    | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}`,
-    "abs" | "sqrt"
->;
-
-/** Should be the same type as Object3D.userData */
-export type NodeUserData = Record<string, any>;
-
-/** generic key value type,curretly used by nodes  */
-export interface AnyObject {
-    [key: string]: any;
-}
-
-/** a generic JSON type, used by nodes only */
-export type AnyJson = any;
+export declare const NodeShaderStage: {
+    readonly VERTEX: "vertex";
+    readonly FRAGMENT: "fragment";
+};
+export declare const NodeUpdateType: {
+    readonly NONE: "none";
+    readonly FRAME: "frame";
+    readonly RENDER: "render";
+    readonly OBJECT: "object";
+};
+export declare const NodeType: {
+    readonly BOOLEAN: "bool";
+    readonly INTEGER: "int";
+    readonly FLOAT: "float";
+    readonly VECTOR2: "vec2";
+    readonly VECTOR3: "vec3";
+    readonly VECTOR4: "vec4";
+    readonly MATRIX2: "mat2";
+    readonly MATRIX3: "mat3";
+    readonly MATRIX4: "mat4";
+};
+export type NodeShaderStage = "vertex" | "fragment" | "compute";
+export type NodeUpdateType = "none" | "frame" | "render" | "object";
+export declare const defaultShaderStages: NodeShaderStage[];
+export declare const defaultBuildStages: string[];
+export declare const shaderStages: NodeShaderStage[];
+export declare const vectorComponents: string[];

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

@@ -0,0 +1,30 @@
+import TextureNode from "../accessors/TextureNode.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import UniformNode from "../core/UniformNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class DepthOfFieldNode extends TempNode {
+    textureNode: TextureNode;
+    viewZNode: Node;
+
+    focus: UniformNode<number>;
+    aperture: UniformNode<number>;
+    maxblur: UniformNode<number>;
+
+    constructor(textureNode: TextureNode, viewZNode: Node, focus?: number, aperture?: number, maxblur?: number);
+}
+
+export const dof: (
+    node: NodeRepresentation,
+    viewZNode: NodeRepresentation,
+    focus?: number,
+    aperture?: number,
+    maxblur?: number,
+) => ShaderNodeObject<DepthOfFieldNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        dof: typeof dof;
+    }
+}

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

@@ -0,0 +1,32 @@
+import { Vector2 } from "three";
+import TextureNode from "../accessors/TextureNode.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import UniformNode from "../core/UniformNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class DotScreenNode extends TempNode {
+    colorNode: Node;
+    center: UniformNode<Vector2>;
+    angle: UniformNode<number>;
+    scale: UniformNode<number>;
+
+    constructor(colorNode: Node, center?: Vector2, angle?: number, scale?: number);
+
+    getTextureNode(): ShaderNodeObject<TextureNode>;
+
+    setSize(width: number, height: number): void;
+}
+
+export const dotScreen: (
+    node: NodeRepresentation,
+    center?: Vector2,
+    angle?: number,
+    scale?: number,
+) => ShaderNodeObject<DotScreenNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        dotScreen: typeof dotScreen;
+    }
+}

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

@@ -27,7 +27,7 @@ export default class PassNode extends TempNode {
 
     getViewZNode(): ShaderNodeObject<Node>;
 
-    getDepthNode(): ShaderNodeObject<Node>;
+    getLinearDepthNode(): ShaderNodeObject<Node>;
 
     setSize(width: number, height: number): void;
 

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

@@ -0,0 +1,24 @@
+import TextureNode from "../accessors/TextureNode.js";
+import TempNode from "../core/TempNode.js";
+import UniformNode from "../core/UniformNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class RGBShiftNode extends TempNode {
+    textureNode: TextureNode;
+    amount: UniformNode<number>;
+    angle: UniformNode<number>;
+
+    constructor(textureNode: TextureNode, amount?: number, angle?: number);
+
+    getTextureNode(): TextureNode;
+
+    setSize(width: number, height: number): void;
+}
+
+export const rgbShift: (node: NodeRepresentation, amount?: number, angle?: number) => ShaderNodeObject<RGBShiftNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        rgbShift: typeof rgbShift;
+    }
+}

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

@@ -0,0 +1,17 @@
+import TextureNode from "../accessors/TextureNode.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class SobelOperatorNode extends TempNode {
+    textureNode: TextureNode;
+
+    constructor(textureNode: TextureNode);
+}
+
+export const sobel: (node: NodeRepresentation) => ShaderNodeObject<SobelOperatorNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        sobel: typeof sobel;
+    }
+}