@types/three 0.157.1 → 0.158.0

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

@@ -0,0 +1,78 @@
+import { Color, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from '../../../../src/Three.js';
+
+// disable automatic export, we have some private declarations
+export const NodeShaderStage: {
+    VERTEX: 'vertex';
+    FRAGMENT: 'fragment';
+};
+
+export const NodeUpdateType: {
+    NONE: 'none';
+    FRAME: 'frame';
+    RENDER: 'render';
+    OBJECT: 'object';
+};
+
+export type NodeValueOption = Color | Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4 | boolean | number;
+export type NodeUpdateTypeOption = 'none' | 'frame' | 'object';
+export type NodeShaderStageOption = 'vertex' | 'fragment' | 'compute';
+export type NodeTypeOption =
+    | 'bool'
+    | 'int'
+    | 'float'
+    | 'vec2'
+    | 'vec3'
+    | 'vec4'
+    | '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';
+
+// can be defined with string template type in Typescript 4.1
+export type SwizzleOption = string;
+
+/** Should be the same type as Object3D.userData */
+export interface NodeUserData {
+    [key: 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 const NodeType: {
+    BOOLEAN: 'bool';
+    INTEGER: 'int';
+    FLOAT: 'float';
+    VECTOR2: 'vec2';
+    VECTOR3: 'vec3';
+    VECTOR4: 'vec4';
+    MATRIX3: 'mat3';
+    MATRIX4: 'mat4';
+};

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

@@ -0,0 +1,32 @@
+import TempNode from '../core/TempNode.js';
+import { ShaderNode } from '../shadernode/ShaderNodeBaseElements.js';
+import { Node } from '../Nodes.js';
+
+export const BurnNode: ShaderNode<{ base: Node; blendNode: Node }>;
+
+export const DodgeNode: ShaderNode<{ base: Node; blendNode: Node }>;
+
+export const ScreenNode: ShaderNode<{ base: Node; blendNode: Node }>;
+
+export const OverlayNode: ShaderNode<{ base: Node; blendNode: Node }>;
+
+export type BlendMode =
+    | typeof BlendModeNode.BURN
+    | typeof BlendModeNode.DODGE
+    | typeof BlendModeNode.SCREEN
+    | typeof BlendModeNode.OVERLAY;
+
+export default class BlendModeNode extends TempNode {
+    static BURN: 'burn';
+    static DODGE: 'dodge';
+    static SCREEN: 'screen';
+    static OVERLAY: 'overlay';
+
+    baseNode: Node;
+    blendMode: BlendMode;
+    blendNode: Node;
+
+    constructor(blendMode: BlendMode, baseNode: Node, blendNode: Node);
+
+    setup(): Node;
+}

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

@@ -0,0 +1,20 @@
+import TempNode from '../core/TempNode.js';
+import { Node } from '../Nodes.js';
+
+export type ColorAdjustmentMethod =
+    | typeof ColorAdjustmentNode.SATURATION
+    | typeof ColorAdjustmentNode.VIBRANCE
+    | typeof ColorAdjustmentNode.HUE;
+
+export default class ColorAdjustmentNode extends TempNode {
+    static SATURATION: 'saturation';
+    static VIBRANCE: 'vibrance';
+    static HUE: 'hue';
+
+    method: ColorAdjustmentMethod;
+
+    colorNode: Node;
+    adjustmentNode: Node;
+
+    constructor(method: ColorAdjustmentMethod, colorNode: Node, adjustmentNode?: Node);
+}

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

@@ -0,0 +1,18 @@
+import TempNode from '../core/TempNode.js';
+import Node from '../core/Node.js';
+
+export type ColorSpaceNodeMethod =
+    | typeof ColorSpaceNode.LINEAR_TO_LINEAR
+    | typeof ColorSpaceNode.LINEAR_TO_sRGB
+    | 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';
+
+    method: ColorSpaceNodeMethod;
+    node: Node;
+
+    constructor(method: ColorSpaceNodeMethod | null, node: Node);
+}

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

@@ -0,0 +1,6 @@
+import Node from '../core/Node.js';
+
+export default class FrontFacingNode extends Node {
+    isFrontFacingNode: true;
+    constructor();
+}

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

@@ -0,0 +1,12 @@
+import TempNode from '../core/TempNode.js';
+import { NormalMapTypes } from '../../../../src/Three.js';
+import Node from '../core/Node.js';
+
+export default class NormalMapNode extends TempNode {
+    node: Node;
+    scaleNode: Node | null;
+
+    normalMapType: NormalMapTypes;
+
+    constructor(node: Node, scaleNode?: Node | null);
+}

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

@@ -0,0 +1,8 @@
+import Node from '../core/Node.js';
+
+export default class PosterizeNode extends Node {
+    sourceNode: Node;
+    stepsNode: Node;
+
+    constructor(sourceNode: Node, stepsNode: Node);
+}

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

@@ -0,0 +1,14 @@
+import TempNode from '../core/TempNode.js';
+import Node from '../core/Node.js';
+import { ToneMapping } from '../../../../src/Three.js';
+
+// exposure only
+export const LinearToneMappingNode: Node;
+
+export default class ToneMappingNode extends TempNode {
+    toneMapping: ToneMapping;
+    exposureNode: Node;
+    colorNode: Node | null;
+
+    constructor(toneMapping: ToneMapping, exposureNode?: Node, colorNode?: Node | null);
+}

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

@@ -0,0 +1,23 @@
+import Node from '../core/Node.js';
+
+export type ViewportNodeScope =
+    | typeof ViewportNode.COORDINATE
+    | typeof ViewportNode.RESOLUTION
+    | typeof ViewportNode.TOP_LEFT
+    | typeof ViewportNode.BOTTOM_LEFT
+    | typeof ViewportNode.TOP_RIGHT
+    | 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';
+
+    scope: ViewportNodeScope;
+    isViewportNode: true;
+
+    constructor(scope: ViewportNodeScope);
+}

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

@@ -0,0 +1,9 @@
+import Node from '../core/Node.js';
+import FogNode from './FogNode.js';
+
+export default class FogExp2Node extends FogNode {
+    isFogExp2Node: true;
+    densityNode: Node;
+
+    constructor(colorNode: Node, densityNode: Node);
+}

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

@@ -0,0 +1,10 @@
+import Node from '../core/Node.js';
+
+export default class FogNode extends Node {
+    isFogNode: true;
+    colorNode: Node;
+    factorNode: Node;
+
+    constructor(colorNode: Node, factorNode: Node);
+    mixAssign(outputNode: Node): Node;
+}

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

@@ -0,0 +1,10 @@
+import FogNode from './FogNode.js';
+import Node from '../core/Node.js';
+
+export default class FogRangeNode extends FogNode {
+    isFogRangeNode: true;
+    nearNode: Node;
+    farNode: Node;
+
+    constructor(colorNode: Node, nearNode: Node, farNode: Node);
+}

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

@@ -0,0 +1,6 @@
+import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+import Node from '../../core/Node.js';
+
+declare const BRDF_GGX: ShaderNode<{ lightDirection: Node; f0: Node; f90: Node; roughness: Node }>;
+
+export default BRDF_GGX;

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

@@ -0,0 +1,6 @@
+import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+import Node from '../../core/Node.js';
+
+declare const BRDF_Lambert: ShaderNode<{ diffuseColor: Node }>;
+
+export default BRDF_Lambert;

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

@@ -0,0 +1,10 @@
+import { ShaderNode } from '../../shadernode/ShaderNodeElements.js';
+import Node from '../../core/Node.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 }>;
+
+export default DFGApprox;

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

@@ -0,0 +1,9 @@
+import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+import Node from '../../core/Node.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 }>;
+
+export default D_GGX;

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

@@ -0,0 +1,6 @@
+import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+import Node from '../../core/Node.js';
+
+declare const F_Schlick: ShaderNode<{ f0: Node; f90: Node; dotVH: Node }>;
+
+export default F_Schlick;

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

@@ -0,0 +1,6 @@
+import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+import Node from '../../core/Node.js';
+
+declare const V_GGX_SmithCorrelated: ShaderNode<{ alpha: Node; dotNL: Node; dotNV: Node }>;
+
+export default V_GGX_SmithCorrelated;

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

@@ -0,0 +1,11 @@
+import { ShaderNode } from '../shadernode/ShaderNodeElements.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 PhysicalLightingModel;

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

@@ -0,0 +1,5 @@
+import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+
+declare const getGeometryRoughness: ShaderNode;
+
+export default getGeometryRoughness;

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

@@ -0,0 +1,6 @@
+import { ShaderNode } from '../../shadernode/ShaderNodeElements.js';
+import Node from '../../core/Node.js';
+
+declare const getRoughness: ShaderNode<{ roughness: Node }>;
+
+export default getRoughness;

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

@@ -0,0 +1,13 @@
+import { Color, Vector2, Vector3, Vector4 } from '../../../../src/Three.js';
+import Node from '../core/Node.js';
+import NodeBuilder from '../core/NodeBuilder.js';
+
+export type RangeModeBound = number | Color | Vector2 | Vector3 | Vector4;
+
+export default class RangeNode extends Node {
+    min: RangeModeBound;
+    max: RangeModeBound;
+
+    constructor(min: RangeModeBound, max: RangeModeBound);
+    getVectorLength(builder: NodeBuilder): number;
+}

three/examples/jsm/nodes/gpgpu/ComputeNode.d.ts

@@ -0,0 +1,11 @@
+import Node from '../core/Node.js';
+
+export default class ComputeNode extends Node {
+    isComputeNode: true;
+
+    count: number;
+    workgroupSize: number[];
+    dispatchCount: number;
+
+    constructor(computeNode: Node, count: number, workgroupSize?: number[]);
+}

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

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

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

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

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

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

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

@@ -0,0 +1,13 @@
+import AnalyticLightNode from './AnalyticLightNode.js';
+import Object3DNode from '../accessors/Object3DNode.js';
+import { HemisphereLight } from '../../../../src/Three.js';
+import Node from '../core/Node.js';
+
+export default class HemisphereLightNode extends AnalyticLightNode<HemisphereLight> {
+    lightPositionNode: Object3DNode;
+    lightDirectionNode: Node;
+
+    groundColorNode: Node;
+
+    constructor(light?: HemisphereLight | null);
+}

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

@@ -0,0 +1,4 @@
+import { ShaderNode } from '../shadernode/ShaderNode.js';
+import Node from '../core/Node.js';
+
+export const getDistanceAttenuation: ShaderNode<{ lightDistance: Node; cutoffDistance: Node; decayExponent: Node }>;

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

@@ -0,0 +1,15 @@
+import ContextNode from '../core/ContextNode.js';
+import Node from '../core/Node.js';
+import { ShaderNode } from '../Nodes.js';
+
+export interface LightingModelNode {
+    indirectDiffuse?: ShaderNode;
+    indirectSpecular?: ShaderNode;
+    ambientOcclusion?: ShaderNode;
+}
+
+export default class LightingContextNode extends ContextNode {
+    lightingModelNode: LightingModelNode | null;
+
+    constructor(node: Node, lightingModelNode?: LightingModelNode | null);
+}

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

@@ -0,0 +1,5 @@
+import Node from '../core/Node.js';
+
+export default abstract class LightingNode extends Node {
+    constructor();
+}

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

@@ -0,0 +1,19 @@
+import { Light } from '../../../../src/Three.js';
+import Node from '../core/Node.js';
+import LightingNode from './LightingNode.js';
+
+export default class LightsNode extends Node {
+    lightNodes: LightingNode[];
+
+    constructor(lightNodes?: LightingNode[]);
+
+    get hasLight(): boolean;
+    getLightNodeByHash(hash: string): LightingNode | null;
+
+    fromLights(lights: Light[]): this;
+
+    static setReference<T extends Light>(
+        lightClass: { new (): T },
+        lightNodeClass: { new (light: T): LightingNode },
+    ): void;
+}

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

@@ -0,0 +1,10 @@
+import AnalyticLightNode from './AnalyticLightNode.js';
+import Node from '../core/Node.js';
+import { PointLight } from '../../../../src/Three.js';
+
+export default class PointLightNode extends AnalyticLightNode<PointLight> {
+    cutoffDistanceNode: Node;
+    decayExponentNode: Node;
+
+    constructor(light?: PointLight | null);
+}

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

@@ -0,0 +1,15 @@
+import AnalyticLightNode from './AnalyticLightNode.js';
+import Node from '../core/Node.js';
+import { SpotLight } from '../../../../src/Three.js';
+
+export default class PointLightNode extends AnalyticLightNode<SpotLight> {
+    directionNode: Node;
+
+    coneCosNode: Node;
+    penumbraCosNode: Node;
+
+    cutoffDistanceNode: Node;
+    decayExponentNode: Node;
+
+    constructor(light?: SpotLight | null);
+}

three/examples/jsm/nodes/loaders/NodeLoader.d.ts

@@ -0,0 +1,14 @@
+import { Loader, LoadingManager, Texture } from '../../../../src/Three.js';
+import { Node, AnyJson } from '../Nodes.js';
+
+export interface NodeLoaderResult {
+    [hash: string]: Node;
+}
+
+export default class NodeLoader extends Loader<NodeLoaderResult> {
+    constructor(manager?: LoadingManager);
+
+    parseNodes(json: AnyJson): NodeLoaderResult;
+    parse(json: AnyJson): Node;
+    setTextures(textures: { [key: string]: Texture }): this;
+}

three/examples/jsm/nodes/loaders/NodeMaterialLoader.d.ts

@@ -0,0 +1,8 @@
+import { MaterialLoader } from '../../../../src/Three.js';
+import { NodeLoaderResult } from './NodeLoader.js';
+
+export default class NodeMaterialLoader extends MaterialLoader {
+    nodes: NodeLoaderResult;
+
+    setNodes(value: NodeLoaderResult): this;
+}

three/examples/jsm/nodes/loaders/NodeObjectLoader.d.ts

@@ -0,0 +1,9 @@
+import { NodeLoaderResult } from './NodeLoader.js';
+import { Material, ObjectLoader, Texture } from '../../../../src/Three.js';
+import { AnyJson } from '../core/constants.js';
+
+export default class NodeObjectLoader extends ObjectLoader {
+    parseNodes(json: AnyJson, textures: { [key: string]: Texture }): NodeLoaderResult;
+
+    parseMaterials(json: AnyJson, textures: { [key: string]: Texture }): { [key: string]: Material };
+}

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

@@ -0,0 +1,9 @@
+import NodeMaterial from './NodeMaterial.js';
+import { ShaderMaterialParameters } from '../../../../src/Three.js';
+
+export default class LineBasicNodeMaterial extends NodeMaterial {
+    isLineBasicNodeMaterial: true;
+
+    constructor(parameters?: ShaderMaterialParameters);
+    copy(source: LineBasicNodeMaterial): this;
+}

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

@@ -0,0 +1,17 @@
+import NodeMaterial from './NodeMaterial.js';
+import LineBasicNodeMaterial from './LineBasicNodeMaterial.js';
+import MeshBasicNodeMaterial from './MeshBasicNodeMaterial.js';
+import MeshStandardNodeMaterial from './MeshStandardNodeMaterial.js';
+import PointsNodeMaterial from './PointsNodeMaterial.js';
+import SpriteNodeMaterial from './SpriteNodeMaterial.js';
+import MeshPhysicalNodeMaterial from './MeshPhysicalNodeMaterial.js';
+
+export {
+    NodeMaterial,
+    LineBasicNodeMaterial,
+    MeshBasicNodeMaterial,
+    MeshPhysicalNodeMaterial,
+    MeshStandardNodeMaterial,
+    PointsNodeMaterial,
+    SpriteNodeMaterial,
+};

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

@@ -0,0 +1,10 @@
+import NodeMaterial from './NodeMaterial.js';
+import { ShaderMaterialParameters } from '../../../../src/Three.js';
+
+export default class MeshBasicNodeMaterial extends NodeMaterial {
+    isMeshBasicNodeMaterial: true;
+    lights: true;
+
+    constructor(paramters?: ShaderMaterialParameters);
+    copy(source: MeshBasicNodeMaterial): this;
+}

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

@@ -0,0 +1,22 @@
+import { ShaderMaterialParameters } from '../../../../src/Three.js';
+import { Swizzable, CheckerNode, Node } from '../Nodes.js';
+
+import MeshStandardNodeMaterial from './MeshStandardNodeMaterial.js';
+
+export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
+    iridescenceNode: null | Swizzable<CheckerNode>;
+    iridescenceIORNode: null | Swizzable;
+    iridescenceThicknessNode: null | Swizzable;
+
+    specularIntensityNode: Node | null;
+    specularColorNode: Node | null;
+
+    transmissionNode: Node | null;
+    thicknessNode: Node | null;
+    attenuationDistanceNode: Node | null;
+    attenuationColorNode: Node | null;
+
+    constructor(parameters: ShaderMaterialParameters);
+
+    copy(source: MeshPhysicalNodeMaterial): this;
+}

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

@@ -0,0 +1,18 @@
+import { ShaderMaterialParameters } from '../../../../src/Three.js';
+import Node from '../core/Node.js';
+import NodeMaterial from './NodeMaterial.js';
+
+export default class MeshStandardNodeMaterial extends NodeMaterial {
+    isMeshStandardNodeMaterial: true;
+
+    emissiveNode: Node | null;
+
+    metalnessNode: Node | null;
+    roughnessNode: Node | null;
+
+    clearcoatNode: Node | null;
+    clearcoatRoughnessNode: Node | null;
+
+    constructor(paramters?: ShaderMaterialParameters);
+    copy(source: MeshStandardNodeMaterial): this;
+}

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

@@ -0,0 +1,38 @@
+import { Material, ShaderMaterial } from '../../../../src/Three.js';
+import NodeBuilder from '../core/NodeBuilder.js';
+import Node from '../core/Node.js';
+import { LightingModelNode } from '../lighting/LightingContextNode.js';
+
+export default class NodeMaterial extends ShaderMaterial {
+    isNodeMaterial: true;
+
+    type: string;
+
+    lights: true;
+    normals: true;
+
+    lightsNode: Node | null;
+    envNode: Node | null;
+
+    colorNode: Node | null;
+    normalNode: Node | null;
+    opacityNode: Node | null;
+    backdropNode: Node | null;
+    backdropAlphaNode: Node | null;
+    alphaTestNode: Node | null;
+
+    positionNode: Node | null;
+
+    constructor();
+
+    build(builder: NodeBuilder): void;
+    customProgramCacheKey(): string;
+    generatePosition(builder: NodeBuilder): void;
+    generateDiffuseColor(builder: NodeBuilder): void;
+    generateLight(
+        builder: NodeBuilder,
+        lights: { diffuseColorNode: Node; lightingModelNode: LightingModelNode; lightsNode?: Node },
+    ): void;
+    generateOutput(builder: NodeBuilder, lights: { diffuseColorNode: Node; outgoingLightNode: Node }): void;
+    static fromMaterial(m: Material): NodeMaterial;
+}