@types/three 0.142.0 → 0.143.2

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

@@ -0,0 +1,134 @@
+import {
+    BufferGeometry,
+    Material,
+    Object3D,
+    Renderer,
+    Scene,
+    Texture,
+    TextureEncoding,
+    WebGLRenderTarget,
+} from '../../../../src/Three';
+import FogNode from '../fog/FogNode';
+import LightsNode from '../lighting/LightsNode';
+import { nodeObject } from '../Nodes';
+import { AnyObject, NodeShaderStageOption, NodeTypeOption } from './constants';
+import Node from './Node';
+import NodeAttribute from './NodeAttribute';
+import NodeParser from './NodeParser';
+import NodeUniform from './NodeUniform';
+import NodeVar from './NodeVar';
+import NodeVary from './NodeVary';
+
+export type BuildStageOption = 'construct' | 'analyze' | 'generate';
+
+export interface FlowData {
+    code: string;
+}
+
+export interface NodeData {
+    vertex: AnyObject;
+    fragment: AnyObject;
+    compute: AnyObject;
+}
+
+export type NodeBuilderContext = AnyObject;
+
+export default abstract class NodeBuilder {
+    object: Object3D;
+    material: Material;
+    geometry: BufferGeometry;
+    renderer: Renderer;
+    parser: NodeParser;
+
+    nodes: Node[];
+    updateNodes: Node[];
+    hashNodes: { [hash: string]: Node };
+
+    scene: Scene;
+    lightsNode: LightsNode;
+    fogNode: FogNode;
+
+    vertexShader: string;
+    fragmentShader: string;
+    computeShader: string;
+
+    shaderStage: NodeShaderStageOption | null;
+    buildStage: BuildStageOption | null;
+    stack: Node[];
+    get node(): Node;
+
+    addStack(node: Node): void;
+    removeStack(node: Node): void;
+    setHashNode(node: Node, hash: string): void;
+    addNode(node: Node): void;
+    getMethod(method: string): string;
+    getNodeFromHash(hash: string): Node;
+
+    addFlow(shaderStage: NodeShaderStageOption, node: Node): Node;
+
+    setContext(context: NodeBuilderContext): void;
+    getContext(): NodeBuilderContext;
+    isAvailable(name: string): boolean;
+
+    abstract getInstanceIndex(): string;
+
+    abstract getFrontFacing(): string;
+
+    abstract getTexture(textureProperty: string, uvSnippet: string): string;
+
+    abstract getTextureLevel(textureProperty: string, uvSnippet: string, levelSnippet: string): string;
+
+    abstract getCubeTexture(textureProperty: string, uvSnippet: string): string;
+    abstract getCubeTextureLevel(textureProperty: string, uvSnippet: string, levelSnippet: string): string;
+
+    // @TODO: rename to .generateConst()
+    getConst(type: NodeTypeOption, value: unknown): Node;
+    getType(type: NodeTypeOption): NodeTypeOption;
+
+    generateMethod(method: string): string;
+
+    getAttribute(name: string, type: NodeTypeOption): NodeAttribute;
+
+    getPropertyName(node: Node, shaderStage: NodeShaderStageOption): string;
+    isVector(type: NodeTypeOption): boolean;
+
+    isMatrix(type: NodeTypeOption): boolean;
+    isReference(type: NodeTypeOption): boolean;
+    isShaderStage(shaderStage: NodeShaderStageOption): 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, shaderStage: NodeShaderStageOption, type: NodeTypeOption): NodeUniform;
+    getVarFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): NodeVar;
+    getVaryFromNode(node: Node, type: NodeTypeOption): NodeVary;
+    getCodeFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): string;
+    addFlowCode(code: string): void;
+    getFlowData(node: Node, shaderStage: NodeShaderStageOption): FlowData;
+    flowNode(node: Node): FlowData;
+    flowChildNode(node: Node, output?: string | null): FlowData;
+    flowNodeFromShaderStage(
+        shaderStage: NodeShaderStageOption,
+        node: Node,
+        output?: string | null,
+        propertyName?: string,
+    ): FlowData;
+    abstract getAttributes(shaderStage: NodeShaderStageOption): string;
+    abstract getVarys(shaderStage: NodeShaderStageOption): string;
+    getVars(shaderStage: NodeShaderStageOption): string;
+    abstract getUniforms(stage: NodeShaderStageOption): string;
+    getCodes(shaderStage: NodeShaderStageOption): string;
+    getHash(): string;
+    setShaderStage(shaderStage: NodeShaderStageOption): void;
+    getShaderStage(): NodeShaderStageOption;
+    setBuildStage(buildStage: BuildStageOption): void;
+    getBuildStage(): BuildStageOption;
+    abstract buildCode(): void;
+    build(): this;
+    format(snippet: string, fromType: NodeTypeOption, toType: NodeTypeOption): string;
+    getSignature(): string;
+}

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

@@ -0,0 +1,4 @@
+export default class NodeCode {
+    isNodeCode: true;
+    constructor(name: string, type: string, code?: string);
+}

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

@@ -0,0 +1,19 @@
+import { Camera, Material, Object3D, Renderer } from '../../../../src/Three';
+
+import Node from './Node';
+
+export default class NodeFrame {
+    time: number;
+    deltaTime: number;
+    frameId: number;
+    startTime: null | number;
+    renderer: null | Renderer;
+    material: null | Material;
+    camera: null | Camera;
+    object: null | Object3D;
+
+    constructor();
+
+    updateNode(node: Node): void;
+    update(): void;
+}

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

@@ -0,0 +1,13 @@
+import NodeFunctionInput from './NodeFunctionInput';
+
+export default abstract class NodeFunction {
+    isNodeFunction: true;
+    type: string;
+    inputs: NodeFunctionInput[];
+    name: string;
+    presicion: string;
+
+    constructor(type: string, inputs: NodeFunctionInput[], name?: string, presicion?: string);
+
+    abstract getCode(name?: string): string;
+}

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

@@ -0,0 +1,7 @@
+export default class NodeFunctionInput {
+    isNodeFunctionInput: true;
+    count: null | number;
+    qualifier: string;
+    isConst: boolean;
+    constructor(type: string, name: string, count?: number, qualifier?: string, isConst?: boolean);
+}

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

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

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

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

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

@@ -0,0 +1,13 @@
+import { NodeValueOption } from './constants';
+import InputNode from './InputNode';
+
+export default class NodeUniform {
+    isNodeUniform: true;
+    name: string;
+    type: string;
+    node: InputNode;
+    needsUpdate: boolean;
+    value: NodeValueOption;
+
+    constructor(name: string, type: string, node: InputNode, needsUpdate?: boolean);
+}

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

@@ -0,0 +1,6 @@
+import { NodeValueOption } from './constants';
+import Node from './Node';
+
+export function getNodesKeys(object: Node): string[];
+export function getValueType(value: NodeValueOption): string | null;
+export function getValueFromType(type: string, ...params: number[]): NodeValueOption | null;

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

@@ -0,0 +1,6 @@
+export default class NodeVar {
+    isNodeVar: true;
+    name: string;
+    type: string;
+    constructor(name: string, type: string);
+}

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

@@ -0,0 +1,6 @@
+export default class NodeVary {
+    name: string;
+    type: string;
+    isNodeVary: boolean;
+    constructor(name: string, type: string);
+}

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

@@ -0,0 +1,6 @@
+import { NodeTypeOption } from './constants';
+import Node from './Node';
+
+export default class PropertyNode extends Node {
+    constructor(name?: string, nodeType?: NodeTypeOption);
+}

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

@@ -0,0 +1,8 @@
+import { NodeTypeOption } from './constants';
+import Node from './Node';
+
+export default class TempNode extends Node {
+    isTempNode: true;
+
+    constructor(type: NodeTypeOption | null);
+}

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

@@ -0,0 +1,10 @@
+import { NodeTypeOption, NodeValueOption } from './constants';
+import InputNode from './InputNode';
+import NodeBuilder from './NodeBuilder';
+
+export default class UniformNode extends InputNode {
+    isUniformNode: true;
+
+    constructor(value: NodeValueOption, nodeType?: NodeTypeOption | null);
+    getUniformHash(builder: NodeBuilder): string;
+}

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

@@ -0,0 +1,16 @@
+import { OperatorNodeOp } from '../math/OperatorNode';
+import Node from './Node';
+
+export default class VarNode extends Node {
+    node: Node;
+    name: string | null;
+
+    constructor(node: Node, name?: string | null);
+
+    op(op: OperatorNodeOp, ...params: Node[]): this;
+    assign(...params: Node[]): this;
+    add(...params: Node[]): this;
+    sub(...params: Node[]): this;
+    mul(...params: Node[]): this;
+    div(...params: Node[]): this;
+}

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

@@ -0,0 +1,8 @@
+import Node from './Node';
+
+export default class VaryNode extends Node {
+    node: Node;
+    name: string | null;
+
+    constructor(node: Node, name?: string | null);
+}

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

@@ -0,0 +1,77 @@
+import { Color, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from '../../../../src/Three';
+
+// disable automatic export, we have some private declarations
+export const NodeShaderStage: {
+    Vertex: 'vertex';
+    Fragment: 'fragment';
+};
+
+export const NodeUpdateType: {
+    None: 'none';
+    Frame: 'frame';
+    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/ColorAdjustmentNode.d.ts

@@ -0,0 +1,20 @@
+import TempNode from '../core/TempNode';
+import { Node } from '../Nodes';
+
+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,15 @@
+import { TextureEncoding } from '../../../../src/Three';
+import TempNode from '../core/TempNode';
+import Node from '../core/Node';
+export type ColorSpaceNodeMethod = typeof ColorSpaceNode.LINEAR_TO_LINEAR | typeof ColorSpaceNode.LINEAR_TO_SRGB;
+
+export default class ColorSpaceNode extends TempNode {
+    static LINEAR_TO_LINEAR: 'LinearToLinear';
+    static LINEAR_TO_SRGB: 'LinearTosRGB';
+
+    method: ColorSpaceNodeMethod;
+    node: Node;
+
+    constructor(method: ColorSpaceNodeMethod | null, node: Node);
+    fromEncoding(encoding: TextureEncoding): this;
+}

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

@@ -0,0 +1,6 @@
+import Node from '../core/Node';
+
+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';
+import { NormalMapTypes } from '../../../../src/Three';
+import Node from '../core/Node';
+
+export default class NormalMapNode extends TempNode {
+    node: Node;
+    scaleNode: Node | null;
+
+    normalMapType: NormalMapTypes;
+
+    constructor(node: Node, scaleNode?: Node | null);
+}

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

@@ -0,0 +1,14 @@
+import TempNode from '../core/TempNode';
+import Node from '../core/Node';
+import { ToneMapping } from '../../../../src/Three';
+
+// 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/fog/FogNode.d.ts

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

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

@@ -0,0 +1,10 @@
+import FogNode from './FogNode';
+import Node from '../core/Node';
+
+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';
+import Node from '../../core/Node';
+
+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';
+import Node from '../../core/Node';
+
+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';
+import Node from '../../core/Node';
+
+// 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';
+import Node from '../../core/Node';
+
+// 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';
+import Node from '../../core/Node';
+
+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';
+import Node from '../../core/Node';
+
+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';
+import Node from '../core/Node';
+
+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/light/getDistanceAttenuation.d.ts

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

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

@@ -0,0 +1,5 @@
+import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements';
+
+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';
+import Node from '../../core/Node';
+
+declare const getRoughness: ShaderNode<{ roughness: Node }>;
+
+export default getRoughness;

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

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

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

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

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

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