@types/three 0.159.0 → 0.161.0

three/examples/jsm/nodes/accessors/PointUVNode.d.ts

@@ -1,7 +1,10 @@
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class PointUVNode extends Node {
     isPointUVNode: true;
 
     constructor();
 }
+
+export const pointUV: ShaderNodeObject<PointUVNode>;

three/examples/jsm/nodes/accessors/PositionNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type PositionNodeScope =
     | typeof PositionNode.GEOMETRY
@@ -19,3 +20,10 @@ export default class PositionNode extends Node {
 
     constructor(scope?: PositionNodeScope);
 }
+
+export const positionGeometry: ShaderNodeObject<PositionNode>;
+export const positionLocal: ShaderNodeObject<PositionNode>;
+export const positionWorld: ShaderNodeObject<PositionNode>;
+export const positionWorldDirection: ShaderNodeObject<PositionNode>;
+export const positionView: ShaderNodeObject<PositionNode>;
+export const positionViewDirection: ShaderNodeObject<PositionNode>;

three/examples/jsm/nodes/accessors/ReferenceNode.d.ts

@@ -1,5 +1,6 @@
 import Node from '../core/Node.js';
-import { NodeTypeOption } from '../Nodes.js';
+import { NodeTypeOption } from '../core/constants.js';
+import { NodeOrType, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class ReferenceNode<T> extends Node {
     object: T;
@@ -11,3 +12,5 @@ export default class ReferenceNode<T> extends Node {
 
     setNodeType(uniformType: NodeTypeOption): void;
 }
+
+export const reference: <T>(name: string, nodeOrType: NodeOrType, object: T) => ShaderNodeObject<ReferenceNode<T>>;

three/examples/jsm/nodes/accessors/ReflectVectorNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class ReflectVectorNode extends Node {
     constructor();
@@ -6,3 +7,5 @@ export default class ReflectVectorNode extends Node {
     getHash(): 'reflectVector';
     setup(): Node;
 }
+
+export const reflectVector: ShaderNodeObject<ReflectVectorNode>;

three/examples/jsm/nodes/accessors/SkinningNode.d.ts

@@ -1,5 +1,6 @@
 import { SkinnedMesh } from '../../../../src/Three.js';
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class SkinningNode extends Node {
     skinIndexNode: Node;
@@ -11,3 +12,5 @@ export default class SkinningNode extends Node {
 
     constructor(skinnedMesh: SkinnedMesh);
 }
+
+export function skinning(skinnedMesh: SkinnedMesh): ShaderNodeObject<SkinningNode>;

three/examples/jsm/nodes/accessors/StorageBufferNode.d.ts

@@ -1,6 +1,13 @@
-import { NodeTypeOption } from '../Nodes.js';
 import BufferNode from './BufferNode.js';
+import { NodeTypeOption } from '../core/constants.js';
+import { NodeOrType, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class StorageBufferNode extends BufferNode {
     constructor(value: ArrayLike<number>, bufferType: NodeTypeOption, bufferCount?: number);
 }
+
+export const storage: (
+    value: ArrayLike<number>,
+    nodeOrType: NodeOrType,
+    count: number,
+) => ShaderNodeObject<StorageBufferNode>;

three/examples/jsm/nodes/accessors/TangentNode.d.ts

@@ -1,4 +1,6 @@
 import Node from '../core/Node.js';
+import MathNode from '../math/MathNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type TangentNodeScope =
     | typeof TangentNode.LOCAL
@@ -16,3 +18,10 @@ export default class TangentNode extends Node {
 
     constructor(scope?: TangentNodeScope);
 }
+
+export const tangentGeometry: ShaderNodeObject<TangentNode>;
+export const tangentLocal: ShaderNodeObject<TangentNode>;
+export const tangentView: ShaderNodeObject<TangentNode>;
+export const tangentWorld: ShaderNodeObject<TangentNode>;
+export const transformedTangentView: ShaderNodeObject<MathNode>;
+export const transformedTangentWorld: ShaderNodeObject<MathNode>;

three/examples/jsm/nodes/accessors/TextureBicubicNode.d.ts

@@ -0,0 +1,18 @@
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import TempNode from '../core/TempNode.js';
+
+export default class TextureBicubicNode extends TempNode {
+    textureNode: Node;
+    blurNode: Node;
+
+    constructor(textureNode: Node, blurNode?: Node);
+}
+
+export const textureBicubic: (textureNode: Node, blurNode?: NodeRepresentation) => ShaderNodeObject<TextureBicubicNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        bicubic: typeof textureBicubic;
+    }
+}

three/examples/jsm/nodes/accessors/TextureNode.d.ts

@@ -1,14 +1,30 @@
 import { Texture } from '../../../../src/Three.js';
 import UniformNode from '../core/UniformNode.js';
-import { Node } from '../Nodes.js';
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
-export default class TextureNode extends UniformNode {
+export default class TextureNode extends UniformNode<Texture> {
     isTextureNode: true;
 
-    uvNode: Node | null;
-    levelNode: Node | null;
+    uvNode: ShaderNodeObject<Node> | null;
+    levelNode: ShaderNodeObject<Node> | null;
 
-    constructor(value: Texture, uvNode?: Node, levelNode?: Node | null);
+    constructor(value: Texture, uvNode?: ShaderNodeObject<Node>, levelNode?: ShaderNodeObject<Node> | null);
 
     getDefaultUV(): Node;
+
+    clone(): this;
+}
+
+export const texture: (
+    value: Texture,
+    uvNode?: NodeRepresentation,
+    levelNode?: NodeRepresentation,
+) => ShaderNodeObject<TextureNode>;
+export const sampler: (aTexture: Texture | TextureNode) => ShaderNodeObject<Node>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        texture: typeof texture;
+    }
 }

three/examples/jsm/nodes/accessors/UVNode.d.ts

@@ -1,4 +1,5 @@
 import AttributeNode from '../core/AttributeNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class UVNode extends AttributeNode {
     isUVNode: true;
@@ -6,3 +7,5 @@ export default class UVNode extends AttributeNode {
 
     constructor(index?: number);
 }
+
+export const uv: (index?: number) => ShaderNodeObject<UVNode>;

three/examples/jsm/nodes/accessors/UserDataNode.d.ts

@@ -1,7 +1,14 @@
 import { NodeTypeOption, NodeUserData } from '../core/constants.js';
 import ReferenceNode from './ReferenceNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class UserDataNode extends ReferenceNode<NodeUserData> {
     userData: NodeUserData | null;
     constructor(property: string, inputType: NodeTypeOption, userData?: NodeUserData | null);
 }
+
+export const userData: (
+    name: string,
+    inputType: NodeTypeOption,
+    userData?: NodeUserData,
+) => ShaderNodeObject<UserDataNode>;

three/examples/jsm/nodes/accessors/VertexColorNode.d.ts

@@ -0,0 +1,12 @@
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import AttributeNode from '../core/AttributeNode.js';
+
+export default class VertexColorNode extends AttributeNode {
+    readonly isVertexColorNode: true;
+
+    index: number;
+
+    constructor(index?: number);
+}
+
+export const vertexColor: (index?: number) => ShaderNodeObject<VertexColorNode>;

three/examples/jsm/nodes/code/CodeNode.d.ts

@@ -1,5 +1,7 @@
 import Node from '../core/Node.js';
 import NodeBuilder from '../core/NodeBuilder.js';
+import { NodeTypeOption } from '../core/constants.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export interface CodeNodeInclude {
     build(builder: NodeBuilder): void;
@@ -13,3 +15,5 @@ export default class CodeNode extends Node {
     setIncludes(includes: CodeNodeInclude[]): this;
     getIncludes(builder: NodeBuilder): CodeNodeInclude[];
 }
+
+export const code: (code: string, nodeType?: NodeTypeOption) => ShaderNodeObject<CodeNode>;

three/examples/jsm/nodes/code/ExpressionNode.d.ts

@@ -1,7 +1,10 @@
 import { NodeTypeOption } from '../core/constants.js';
 import TempNode from '../core/TempNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class ExpressionNode extends TempNode {
     snipped: string; /* sic */
     constructor(snipped?: string, nodeType?: NodeTypeOption);
 }
+
+export const expression: (snipped?: string, nodeType?: NodeTypeOption) => ShaderNodeObject<ExpressionNode>;

three/examples/jsm/nodes/code/FunctionCallNode.d.ts

@@ -1,6 +1,7 @@
-import FunctionNode from './FunctionNode.js';
+import FunctionNode, { FunctionNodeArguments } from './FunctionNode.js';
 import TempNode from '../core/TempNode.js';
 import Node from '../core/Node.js';
+import { ProxiedObject, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class FunctionCallNode<P extends Node[] | { [name: string]: Node }> extends TempNode {
     functionNode: FunctionNode<P>;
@@ -11,3 +12,14 @@ export default class FunctionCallNode<P extends Node[] | { [name: string]: Node
     setParameters(parameters: P): this;
     getParameters(): P;
 }
+
+export const call: <P extends FunctionNodeArguments>(
+    functionNode?: FunctionNode<P>,
+    parameters?: ProxiedObject<P>,
+) => ShaderNodeObject<FunctionCallNode<P>>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        call: typeof call;
+    }
+}

three/examples/jsm/nodes/code/FunctionNode.d.ts

@@ -4,6 +4,7 @@ import NodeBuilder from '../core/NodeBuilder.js';
 import NodeFunction from '../core/NodeFunction.js';
 import NodeFunctionInput from '../core/NodeFunctionInput.js';
 import Node from '../core/Node.js';
+import { ProxiedObject, ProxiedTuple, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type FunctionNodeArguments = Node[] | { [name: string]: Node };
 
@@ -15,3 +16,19 @@ export default class FunctionNode<P extends Node[] | { [name: string]: Node }> e
     getNodeFunction(builder: NodeBuilder): NodeFunction;
     call(parameters: P): FunctionCallNode<P>;
 }
+
+export type Fn<P extends FunctionNodeArguments> = P extends readonly [...unknown[]]
+    ? ProxiedTuple<P>
+    : readonly [ProxiedObject<P>];
+
+export const func: <P extends FunctionNodeArguments>(
+    code: string,
+    includes?: CodeNodeInclude[],
+    // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+) => { call: (...params: Fn<P>) => ShaderNodeObject<Node> };
+
+export const fn: <P extends FunctionNodeArguments>(
+    code: string,
+    includes?: CodeNodeInclude[],
+    // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+) => (...params: Fn<P>) => ShaderNodeObject<Node>;

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

@@ -1,7 +1,7 @@
 import UniformNode from './UniformNode.js';
 import Node from './Node.js';
 
-export default class ArrayUniformNode extends UniformNode {
+export default class ArrayUniformNode extends UniformNode<undefined> {
     isArrayUniformNode: true;
     nodes: Node[];
     constructor(nodes?: Node[]);

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

@@ -0,0 +1,17 @@
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from './Node.js';
+import TempNode from './TempNode.js';
+
+export default class AssignNode extends TempNode {
+    constructor(targetNode: Node, sourceNode: Node);
+
+    hasDependencies(): false;
+}
+
+export const assign: (targetNode: NodeRepresentation, sourceNode: NodeRepresentation) => ShaderNodeObject<AssignNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        assign: typeof assign;
+    }
+}

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

@@ -1,9 +1,12 @@
 import { NodeTypeOption } from './constants.js';
 import Node from './Node.js';
 import NodeBuilder from './NodeBuilder.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class AttributeNode extends Node {
     constructor(attributeName: string, nodeType?: NodeTypeOption | null);
     setAttributeName(attributeName: string): this;
     getAttributeName(builder: NodeBuilder): string;
 }
+
+export const attribute: (name: string, nodeType: NodeTypeOption) => ShaderNodeObject<Node>;

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

@@ -1,4 +1,5 @@
 import Node from './Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class BypassNode extends Node {
     isBypassNode: true;
@@ -7,3 +8,11 @@ export default class BypassNode extends Node {
 
     constructor(returnNode: Node, callNode: Node);
 }
+
+export const bypass: (returnNode: NodeRepresentation, callNode: NodeRepresentation) => ShaderNodeObject<BypassNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        bypass: typeof bypass;
+    }
+}

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

@@ -1,5 +1,6 @@
 import Node from './Node.js';
 import NodeCache from './NodeCache.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class CacheNode extends Node {
     isCacheNode: true;
@@ -8,3 +9,13 @@ export default class CacheNode extends Node {
 
     constructor(node: Node, cache?: NodeCache);
 }
+
+export const cache: (node: Node, cache?: NodeCache) => ShaderNodeObject<CacheNode>;
+export const globalCache: (node: Node) => ShaderNodeObject<CacheNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        cache: typeof cache;
+        globalCache: typeof globalCache;
+    }
+}

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

@@ -1,10 +1,10 @@
-import { NodeTypeOption, NodeValueOption } from './constants.js';
+import { NodeTypeOption } from './constants.js';
 import InputNode from './InputNode.js';
 import NodeBuilder from './NodeBuilder.js';
 
-export default class ConstNode extends InputNode {
+export default class ConstNode<Value> extends InputNode<Value> {
     isConstNode: true;
-    constructor(value: NodeValueOption, nodeType?: NodeTypeOption | null);
+    constructor(value: Value, nodeType?: NodeTypeOption | null);
 
     generateConst(builder: NodeBuilder): string;
 }

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

@@ -1,5 +1,6 @@
 import Node from './Node.js';
 import { NodeBuilderContext } from './NodeBuilder.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class ContextNode extends Node {
     isContextNode: true;
@@ -8,3 +9,13 @@ export default class ContextNode extends Node {
 
     constructor(node: Node, context: NodeBuilderContext);
 }
+
+export const context: (node: NodeRepresentation, context: NodeBuilderContext) => ShaderNodeObject<ContextNode>;
+export const label: (node: NodeRepresentation, label: string) => ShaderNodeObject<ContextNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        context: typeof context;
+        label: typeof label;
+    }
+}

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

@@ -0,0 +1,18 @@
+import Node from './Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export type IndexNodeScope = typeof IndexNode.VERTEX | typeof IndexNode.INSTANCE;
+
+export default class IndexNode extends Node {
+    scope: IndexNodeScope;
+
+    readonly isInstanceNode: true;
+
+    constructor(scope: IndexNodeScope);
+
+    static VERTEX: 'vertex';
+    static INSTANCE: 'instance';
+}
+
+export const vertexIndex: ShaderNodeObject<IndexNode>;
+export const instanceIndex: ShaderNodeObject<IndexNode>;

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

@@ -1,15 +1,15 @@
-import { NodeTypeOption, NodeValueOption } from './constants.js';
+import { NodeTypeOption } from './constants.js';
 import Node from './Node.js';
 import NodeBuilder from './NodeBuilder.js';
 
 export type Precision = 'low' | 'medium' | 'high';
 
-export default abstract class InputNode extends Node {
+export default abstract class InputNode<Value> extends Node {
     isInputNode: true;
-    value: NodeValueOption;
+    value: Value;
     precision: Precision | null;
 
-    constructor(value: NodeValueOption, nodeType?: NodeTypeOption | null);
+    constructor(value: Value, nodeType?: NodeTypeOption | null);
 
     getInputType(builder: NodeBuilder): string | null;
     setPrecision(precision: Precision): this;

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

@@ -0,0 +1,36 @@
+import Node from './Node.js';
+import NodeBuilder from './NodeBuilder.js';
+import StackNode from './StackNode.js';
+
+export interface LightingModelReflectedLight {
+    directDiffuse: Node;
+    directSpecular: Node;
+    indirectDiffuse: Node;
+    indirectSpecular: Node;
+}
+
+export interface LightingModelDirectInput {
+    lightDirection: Node;
+    lightColor: Node;
+    reflectedLight: LightingModelReflectedLight;
+}
+
+export interface LightingModelIndirectInput {
+    radiance: Node;
+    irradiance: Node;
+    iblIrradiance: Node;
+    ambientOcclusion: Node;
+    reflectedLight: LightingModelReflectedLight;
+    backdrop: Node;
+    backdropAlpha: Node;
+    outgoingLight: Node;
+}
+
+export default class LightingModel {
+    start(input: LightingModelIndirectInput, stack: StackNode, builder: NodeBuilder): void;
+    finish(input: LightingModelIndirectInput, stack: StackNode, builder: NodeBuilder): void;
+    direct(input: LightingModelDirectInput, stack: StackNode, builder: NodeBuilder): void;
+    indirectDiffuse(input: LightingModelIndirectInput, stack: StackNode, builder: NodeBuilder): void;
+    indirectSpecular(input: LightingModelIndirectInput, stack: StackNode, builder: NodeBuilder): void;
+    ambientOcclusion(input: LightingModelIndirectInput, stack: StackNode, builder: NodeBuilder): void;
+}

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

@@ -1,31 +1,55 @@
-import { AnyJson, NodeTypeOption, NodeUpdateTypeOption } from './constants.js';
+import { AnyJson, NodeTypeOption, NodeUpdateType } from './constants.js';
 import NodeBuilder from './NodeBuilder.js';
 import NodeFrame from './NodeFrame.js';
 
 export default abstract class Node {
-    uuid: string;
-    type: string;
-    isNode: true;
+    readonly isNode: true;
+
     nodeType: NodeTypeOption | null;
-    updateType: NodeUpdateTypeOption;
-    id: number;
+
+    updateType: NodeUpdateType;
+    updateBeforeType: NodeUpdateType;
+
+    uuid: string;
+
+    readonly id: number;
 
     constructor(nodeType?: NodeTypeOption | null);
 
+    get type(): number;
+
     isGlobal(builder: NodeBuilder): boolean;
+
     getChildren(): Node[];
+
+    getCacheKey(): string;
+
     getHash(builder: NodeBuilder): string;
-    getUpdateType(builder: NodeBuilder): NodeUpdateTypeOption;
+
+    getUpdateType(): NodeUpdateType;
+
+    getUpdateBeforeType(): NodeUpdateType;
+
     getNodeType(builder: NodeBuilder, output?: string | null): NodeTypeOption | null;
+
     getReference(builder: NodeBuilder): Node;
+
     setup(builder: NodeBuilder): Node | null;
+
     analyze(builder: NodeBuilder): void;
+
     generate(builder: NodeBuilder, output?: string | null): string;
+
+    updateBefore(frame: NodeFrame): void;
+
     /** This method must be overriden when {@link updateType} !== 'none' */
     update(frame: NodeFrame): void;
+
     build(builder: NodeBuilder, output?: string | null): string;
+
     serialize(json: AnyJson): void;
+
     deserialize(json: AnyJson): void;
+
     toJSON(meta?: string | { textures: {}; images: {}; nodes: {} }): AnyJson;
-    getCacheKey(): string;
 }

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

@@ -3,15 +3,13 @@ import {
     Material,
     Object3D,
     Renderer,
-    Scene,
     Texture,
     TextureEncoding,
     WebGLRenderTarget,
 } from '../../../../src/Three.js';
 import FogNode from '../fog/FogNode.js';
 import LightsNode from '../lighting/LightsNode.js';
-import { nodeObject } from '../Nodes.js';
-import { AnyObject, NodeShaderStageOption, NodeTypeOption } from './constants.js';
+import { AnyObject, NodeShaderStage, NodeTypeOption } from './constants.js';
 import Node from './Node.js';
 import NodeAttribute from './NodeAttribute.js';
 import NodeCache from './NodeCache.js';
@@ -19,6 +17,7 @@ import NodeParser from './NodeParser.js';
 import NodeUniform from './NodeUniform.js';
 import NodeVar from './NodeVar.js';
 import NodeVarying from './NodeVarying.js';
+import StackNode from './StackNode.js';
 
 export type BuildStageOption = 'construct' | 'analyze' | 'generate';
 
@@ -60,9 +59,9 @@ export default abstract class NodeBuilder {
      */
     flowsData: any;
 
-    shaderStage: NodeShaderStageOption | null;
+    shaderStage: NodeShaderStage | null;
     buildStage: BuildStageOption | null;
-    stack: Node[];
+    stack: StackNode;
 
     setHashNode(node: Node, hash: string): void;
     addNode(node: Node): void;
@@ -70,7 +69,7 @@ export default abstract class NodeBuilder {
     getMethod(method: string): string;
     getNodeFromHash(hash: string): Node;
 
-    addFlow(shaderStage: NodeShaderStageOption, node: Node): Node;
+    addFlow(shaderStage: NodeShaderStage, node: Node): Node;
 
     setContext(context: NodeBuilderContext): void;
     getContext(): NodeBuilderContext;
@@ -92,47 +91,52 @@ export default abstract class NodeBuilder {
 
     getAttribute(name: string, type: NodeTypeOption): NodeAttribute;
 
-    getPropertyName(node: Node, shaderStage: NodeShaderStageOption): string;
+    getPropertyName(node: Node, shaderStage: NodeShaderStage): string;
     isVector(type: NodeTypeOption): boolean;
 
     isMatrix(type: NodeTypeOption): boolean;
     isReference(type: NodeTypeOption): boolean;
-    isShaderStage(shaderStage: NodeShaderStageOption): boolean;
+    isShaderStage(shaderStage: NodeShaderStage): boolean;
     getTextureEncodingFromMap(map: Texture | WebGLRenderTarget | unknown): TextureEncoding;
     getComponentType(type: NodeTypeOption): NodeTypeOption;
     getVectorType(type: NodeTypeOption): NodeTypeOption;
     getTypeFromLength(length: number): NodeTypeOption;
     getTypeLength(type: NodeTypeOption): number;
     getVectorFromMatrix(type: NodeTypeOption): NodeTypeOption;
-    getDataFromNode(node: Node, shaderStage?: NodeShaderStageOption): NodeData;
-    getNodeProperties(node: Node, shaderStage?: NodeShaderStageOption): AnyObject;
-    getUniformFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): NodeUniform;
-    getVarFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): NodeVar;
+    getDataFromNode(node: Node, shaderStage?: NodeShaderStage): NodeData;
+    getNodeProperties(node: Node, shaderStage?: NodeShaderStage): AnyObject;
+    getUniformFromNode(
+        node: Node,
+        type: NodeTypeOption,
+        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?: NodeShaderStageOption): string;
+    getCodeFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStage): string;
     addFlowCode(code: string): void;
-    getFlowData(node: Node, shaderStage: NodeShaderStageOption): FlowData;
+    getFlowData(node: Node, shaderStage: NodeShaderStage): FlowData;
     flowNode(node: Node): FlowData;
     flowChildNode(node: Node, output?: string | null): FlowData;
     flowNodeFromShaderStage(
-        shaderStage: NodeShaderStageOption,
+        shaderStage: NodeShaderStage,
         node: Node,
         output?: string | null,
         propertyName?: string,
     ): FlowData;
     hasGeometryAttribute(name: string): boolean;
-    abstract getAttributes(shaderStage: NodeShaderStageOption): string;
-    abstract getVarys(shaderStage: NodeShaderStageOption): string;
-    getVars(shaderStage: NodeShaderStageOption): string;
-    abstract getUniforms(stage: NodeShaderStageOption): string;
-    getCodes(shaderStage: NodeShaderStageOption): string;
+    abstract getAttributes(shaderStage: NodeShaderStage): string;
+    abstract getVarys(shaderStage: NodeShaderStage): string;
+    getVars(shaderStage: NodeShaderStage): string;
+    abstract getUniforms(stage: NodeShaderStage): string;
+    getCodes(shaderStage: NodeShaderStage): string;
     getHash(): string;
-    setShaderStage(shaderStage: NodeShaderStageOption): void;
-    getShaderStage(): NodeShaderStageOption;
+    setShaderStage(shaderStage: NodeShaderStage): void;
+    getShaderStage(): NodeShaderStage;
     setBuildStage(buildStage: BuildStageOption): void;
     getBuildStage(): BuildStageOption;
     abstract buildCode(): void;
-    build(): this;
+    build(createMaterial?: boolean): this;
     format(snippet: string, fromType: NodeTypeOption, toType: NodeTypeOption): string;
     getSignature(): string;
 }