babylonjs-node-editor 5.0.0-beta.6 → 5.0.0-beta.8-snapshot

package/dist/babylon.nodeEditor.module.d.ts

@@ -0,0 +1,2339 @@
+
+declare module "babylonjs-node-editor/blockTools" {
+import { DiscardBlock } from "babylonjs/Materials/Node/Blocks/Fragment/discardBlock";
+import { BonesBlock } from "babylonjs/Materials/Node/Blocks/Vertex/bonesBlock";
+import { InstancesBlock } from "babylonjs/Materials/Node/Blocks/Vertex/instancesBlock";
+import { MorphTargetsBlock } from "babylonjs/Materials/Node/Blocks/Vertex/morphTargetsBlock";
+import { ImageProcessingBlock } from "babylonjs/Materials/Node/Blocks/Fragment/imageProcessingBlock";
+import { ColorMergerBlock } from "babylonjs/Materials/Node/Blocks/colorMergerBlock";
+import { VectorMergerBlock } from "babylonjs/Materials/Node/Blocks/vectorMergerBlock";
+import { ColorSplitterBlock } from "babylonjs/Materials/Node/Blocks/colorSplitterBlock";
+import { VectorSplitterBlock } from "babylonjs/Materials/Node/Blocks/vectorSplitterBlock";
+import { RemapBlock } from "babylonjs/Materials/Node/Blocks/remapBlock";
+import { TextureBlock } from "babylonjs/Materials/Node/Blocks/Dual/textureBlock";
+import { ReflectionTextureBlock } from "babylonjs/Materials/Node/Blocks/Dual/reflectionTextureBlock";
+import { LightBlock } from "babylonjs/Materials/Node/Blocks/Dual/lightBlock";
+import { FogBlock } from "babylonjs/Materials/Node/Blocks/Dual/fogBlock";
+import { VertexOutputBlock } from "babylonjs/Materials/Node/Blocks/Vertex/vertexOutputBlock";
+import { FragmentOutputBlock } from "babylonjs/Materials/Node/Blocks/Fragment/fragmentOutputBlock";
+import { NormalizeBlock } from "babylonjs/Materials/Node/Blocks/normalizeBlock";
+import { AddBlock } from "babylonjs/Materials/Node/Blocks/addBlock";
+import { ModBlock } from "babylonjs/Materials/Node/Blocks/modBlock";
+import { ScaleBlock } from "babylonjs/Materials/Node/Blocks/scaleBlock";
+import { TrigonometryBlock } from "babylonjs/Materials/Node/Blocks/trigonometryBlock";
+import { ConditionalBlock } from "babylonjs/Materials/Node/Blocks/conditionalBlock";
+import { ClampBlock } from "babylonjs/Materials/Node/Blocks/clampBlock";
+import { CrossBlock } from "babylonjs/Materials/Node/Blocks/crossBlock";
+import { DotBlock } from "babylonjs/Materials/Node/Blocks/dotBlock";
+import { MultiplyBlock } from "babylonjs/Materials/Node/Blocks/multiplyBlock";
+import { TransformBlock } from "babylonjs/Materials/Node/Blocks/transformBlock";
+import { NodeMaterialBlockConnectionPointTypes } from "babylonjs/Materials/Node/Enums/nodeMaterialBlockConnectionPointTypes";
+import { FresnelBlock } from "babylonjs/Materials/Node/Blocks/fresnelBlock";
+import { LerpBlock } from "babylonjs/Materials/Node/Blocks/lerpBlock";
+import { NLerpBlock } from "babylonjs/Materials/Node/Blocks/nLerpBlock";
+import { DivideBlock } from "babylonjs/Materials/Node/Blocks/divideBlock";
+import { SubtractBlock } from "babylonjs/Materials/Node/Blocks/subtractBlock";
+import { StepBlock } from "babylonjs/Materials/Node/Blocks/stepBlock";
+import { SmoothStepBlock } from "babylonjs/Materials/Node/Blocks/smoothStepBlock";
+import { InputBlock } from "babylonjs/Materials/Node/Blocks/Input/inputBlock";
+import { OneMinusBlock } from "babylonjs/Materials/Node/Blocks/oneMinusBlock";
+import { ViewDirectionBlock } from "babylonjs/Materials/Node/Blocks/viewDirectionBlock";
+import { LightInformationBlock } from "babylonjs/Materials/Node/Blocks/Vertex/lightInformationBlock";
+import { MaxBlock } from "babylonjs/Materials/Node/Blocks/maxBlock";
+import { MinBlock } from "babylonjs/Materials/Node/Blocks/minBlock";
+import { PerturbNormalBlock } from "babylonjs/Materials/Node/Blocks/Fragment/perturbNormalBlock";
+import { LengthBlock } from "babylonjs/Materials/Node/Blocks/lengthBlock";
+import { DistanceBlock } from "babylonjs/Materials/Node/Blocks/distanceBlock";
+import { FrontFacingBlock } from "babylonjs/Materials/Node/Blocks/Fragment/frontFacingBlock";
+import { NegateBlock } from "babylonjs/Materials/Node/Blocks/negateBlock";
+import { PowBlock } from "babylonjs/Materials/Node/Blocks/powBlock";
+import { Scene } from "babylonjs/scene";
+import { RandomNumberBlock } from "babylonjs/Materials/Node/Blocks/randomNumberBlock";
+import { ReplaceColorBlock } from "babylonjs/Materials/Node/Blocks/replaceColorBlock";
+import { PosterizeBlock } from "babylonjs/Materials/Node/Blocks/posterizeBlock";
+import { ArcTan2Block } from "babylonjs/Materials/Node/Blocks/arcTan2Block";
+import { ReciprocalBlock } from "babylonjs/Materials/Node/Blocks/reciprocalBlock";
+import { GradientBlock } from "babylonjs/Materials/Node/Blocks/gradientBlock";
+import { WaveBlock } from "babylonjs/Materials/Node/Blocks/waveBlock";
+import { NodeMaterial } from "babylonjs/Materials/Node/nodeMaterial";
+import { WorleyNoise3DBlock } from "babylonjs/Materials/Node/Blocks/worleyNoise3DBlock";
+import { SimplexPerlin3DBlock } from "babylonjs/Materials/Node/Blocks/simplexPerlin3DBlock";
+import { NormalBlendBlock } from "babylonjs/Materials/Node/Blocks/normalBlendBlock";
+import { Rotate2dBlock } from "babylonjs/Materials/Node/Blocks/rotate2dBlock";
+import { DerivativeBlock } from "babylonjs/Materials/Node/Blocks/Fragment/derivativeBlock";
+import { RefractBlock } from "babylonjs/Materials/Node/Blocks/refractBlock";
+import { ReflectBlock } from "babylonjs/Materials/Node/Blocks/reflectBlock";
+import { DesaturateBlock } from "babylonjs/Materials/Node/Blocks/desaturateBlock";
+import { PBRMetallicRoughnessBlock } from "babylonjs/Materials/Node/Blocks/PBR/pbrMetallicRoughnessBlock";
+import { SheenBlock } from "babylonjs/Materials/Node/Blocks/PBR/sheenBlock";
+import { AnisotropyBlock } from "babylonjs/Materials/Node/Blocks/PBR/anisotropyBlock";
+import { ReflectionBlock } from "babylonjs/Materials/Node/Blocks/PBR/reflectionBlock";
+import { ClearCoatBlock } from "babylonjs/Materials/Node/Blocks/PBR/clearCoatBlock";
+import { RefractionBlock } from "babylonjs/Materials/Node/Blocks/PBR/refractionBlock";
+import { SubSurfaceBlock } from "babylonjs/Materials/Node/Blocks/PBR/subSurfaceBlock";
+import { CurrentScreenBlock } from "babylonjs/Materials/Node/Blocks/Dual/currentScreenBlock";
+import { ParticleTextureBlock } from "babylonjs/Materials/Node/Blocks/Particle/particleTextureBlock";
+import { ParticleRampGradientBlock } from "babylonjs/Materials/Node/Blocks/Particle/particleRampGradientBlock";
+import { ParticleBlendMultiplyBlock } from "babylonjs/Materials/Node/Blocks/Particle/particleBlendMultiplyBlock";
+import { FragCoordBlock } from "babylonjs/Materials/Node/Blocks/Fragment/fragCoordBlock";
+import { ScreenSizeBlock } from "babylonjs/Materials/Node/Blocks/Fragment/screenSizeBlock";
+import { MatrixBuilderBlock } from "babylonjs/Materials/Node/Blocks/matrixBuilderBlock";
+import { SceneDepthBlock } from "babylonjs/Materials/Node/Blocks/Dual/sceneDepthBlock";
+import { ImageSourceBlock } from "babylonjs/Materials/Node/Blocks/Dual/imageSourceBlock";
+import { CloudBlock } from "babylonjs/Materials/Node/Blocks/cloudBlock";
+import { VoronoiNoiseBlock } from "babylonjs/Materials/Node/Blocks/voronoiNoiseBlock";
+import { ScreenSpaceBlock } from "babylonjs/Materials/Node/Blocks/Fragment/screenSpaceBlock";
+import { TwirlBlock } from "babylonjs/Materials/Node/Blocks/Fragment/twirlBlock";
+import { ElbowBlock } from "babylonjs/Materials/Node/Blocks/elbowBlock";
+import { ClipPlanesBlock } from "babylonjs/Materials/Node/Blocks/Dual/clipPlanesBlock";
+export declare class BlockTools {
+    static GetBlockFromString(data: string, scene: Scene, nodeMaterial: NodeMaterial): ElbowBlock | TwirlBlock | VoronoiNoiseBlock | ScreenSpaceBlock | CloudBlock | MatrixBuilderBlock | DesaturateBlock | RefractBlock | ReflectBlock | DerivativeBlock | Rotate2dBlock | NormalBlendBlock | WorleyNoise3DBlock | SimplexPerlin3DBlock | BonesBlock | InstancesBlock | MorphTargetsBlock | DiscardBlock | ImageProcessingBlock | ColorMergerBlock | VectorMergerBlock | ColorSplitterBlock | VectorSplitterBlock | TextureBlock | ReflectionTextureBlock | LightBlock | FogBlock | VertexOutputBlock | FragmentOutputBlock | AddBlock | ClampBlock | ScaleBlock | CrossBlock | DotBlock | PowBlock | MultiplyBlock | TransformBlock | TrigonometryBlock | RemapBlock | NormalizeBlock | FresnelBlock | LerpBlock | NLerpBlock | DivideBlock | SubtractBlock | ModBlock | StepBlock | SmoothStepBlock | OneMinusBlock | ReciprocalBlock | ViewDirectionBlock | LightInformationBlock | MaxBlock | MinBlock | LengthBlock | DistanceBlock | NegateBlock | PerturbNormalBlock | RandomNumberBlock | ReplaceColorBlock | PosterizeBlock | ArcTan2Block | GradientBlock | FrontFacingBlock | WaveBlock | InputBlock | PBRMetallicRoughnessBlock | SheenBlock | AnisotropyBlock | ReflectionBlock | ClearCoatBlock | RefractionBlock | SubSurfaceBlock | CurrentScreenBlock | ParticleTextureBlock | ParticleRampGradientBlock | ParticleBlendMultiplyBlock | FragCoordBlock | ScreenSizeBlock | SceneDepthBlock | ConditionalBlock | ImageSourceBlock | ClipPlanesBlock | null;
+    static GetColorFromConnectionNodeType(type: NodeMaterialBlockConnectionPointTypes): string;
+    static GetConnectionNodeTypeFromString(type: string): NodeMaterialBlockConnectionPointTypes.Float | NodeMaterialBlockConnectionPointTypes.Vector2 | NodeMaterialBlockConnectionPointTypes.Vector3 | NodeMaterialBlockConnectionPointTypes.Vector4 | NodeMaterialBlockConnectionPointTypes.Color3 | NodeMaterialBlockConnectionPointTypes.Color4 | NodeMaterialBlockConnectionPointTypes.Matrix | NodeMaterialBlockConnectionPointTypes.AutoDetect;
+    static GetStringFromConnectionNodeType(type: NodeMaterialBlockConnectionPointTypes): "" | "Float" | "Vector2" | "Vector3" | "Vector4" | "Matrix" | "Color3" | "Color4";
+}
+
+}
+declare module "babylonjs-node-editor/components/log/logComponent" {
+import * as React from "react";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+interface ILogComponentProps {
+    globalState: GlobalState;
+}
+export declare class LogEntry {
+    message: string;
+    isError: boolean;
+    constructor(message: string, isError: boolean);
+}
+export declare class LogComponent extends React.Component<ILogComponentProps, {
+    logs: LogEntry[];
+}> {
+    constructor(props: ILogComponentProps);
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/components/nodeList/nodeListComponent" {
+import * as React from "react";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+interface INodeListComponentProps {
+    globalState: GlobalState;
+}
+export declare class NodeListComponent extends React.Component<INodeListComponentProps, {
+    filter: string;
+}> {
+    private _onResetRequiredObserver;
+    private static _Tooltips;
+    private _customFrameList;
+    private _customBlockList;
+    constructor(props: INodeListComponentProps);
+    componentWillUnmount(): void;
+    filterContent(filter: string): void;
+    loadCustomFrame(file: File): void;
+    removeItem(value: string): void;
+    loadCustomBlock(file: File): void;
+    removeCustomBlock(value: string): void;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/components/preview/previewAreaComponent" {
+import * as React from "react";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+interface IPreviewAreaComponentProps {
+    globalState: GlobalState;
+    width: number;
+}
+export declare class PreviewAreaComponent extends React.Component<IPreviewAreaComponentProps, {
+    isLoading: boolean;
+}> {
+    private _onIsLoadingChangedObserver;
+    private _onResetRequiredObserver;
+    constructor(props: IPreviewAreaComponentProps);
+    componentWillUnmount(): void;
+    changeBackFaceCulling(value: boolean): void;
+    changeDepthPrePass(value: boolean): void;
+    changeParticleSystemBlendMode(newOne: number): void;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/components/preview/previewManager" {
+import { GlobalState } from "babylonjs-node-editor/globalState";
+import "babylonjs/Rendering/depthRendererSceneComponent";
+export declare class PreviewManager {
+    private _nodeMaterial;
+    private _onBuildObserver;
+    private _onPreviewCommandActivatedObserver;
+    private _onAnimationCommandActivatedObserver;
+    private _onUpdateRequiredObserver;
+    private _onPreviewBackgroundChangedObserver;
+    private _onBackFaceCullingChangedObserver;
+    private _onDepthPrePassChangedObserver;
+    private _onLightUpdatedObserver;
+    private _engine;
+    private _scene;
+    private _meshes;
+    private _camera;
+    private _material;
+    private _globalState;
+    private _currentType;
+    private _lightParent;
+    private _postprocess;
+    private _proceduralTexture;
+    private _particleSystem;
+    private _layer;
+    constructor(targetCanvas: HTMLCanvasElement, globalState: GlobalState);
+    private _handleAnimations;
+    private _prepareLights;
+    private _prepareScene;
+    private _refreshPreviewMesh;
+    private _loadParticleSystem;
+    private _forceCompilationAsync;
+    private _updatePreview;
+    dispose(): void;
+}
+
+}
+declare module "babylonjs-node-editor/components/preview/previewMeshControlComponent" {
+import * as React from "react";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+import { PreviewType } from "babylonjs-node-editor/components/preview/previewType";
+interface IPreviewMeshControlComponent {
+    globalState: GlobalState;
+    togglePreviewAreaComponent: () => void;
+}
+export declare class PreviewMeshControlComponent extends React.Component<IPreviewMeshControlComponent> {
+    private colorInputRef;
+    private filePickerRef;
+    private _onResetRequiredObserver;
+    constructor(props: IPreviewMeshControlComponent);
+    componentWillUnmount(): void;
+    changeMeshType(newOne: PreviewType): void;
+    useCustomMesh(evt: any): void;
+    onPopUp(): void;
+    changeAnimation(): void;
+    changeBackground(value: string): void;
+    changeBackgroundClick(): void;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/components/preview/previewType" {
+export declare enum PreviewType {
+    Sphere = 0,
+    Box = 1,
+    Torus = 2,
+    Cylinder = 3,
+    Plane = 4,
+    ShaderBall = 5,
+    DefaultParticleSystem = 6,
+    Bubbles = 7,
+    Smoke = 8,
+    Rain = 9,
+    Explosion = 10,
+    Fire = 11,
+    Custom = 12
+}
+
+}
+declare module "babylonjs-node-editor/components/propertyTab/inputsPropertyTabComponent" {
+import * as React from "react";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+import { InputBlock } from "babylonjs/Materials/Node/Blocks/Input/inputBlock";
+interface IInputsPropertyTabComponentProps {
+    globalState: GlobalState;
+    inputs: InputBlock[];
+}
+export declare class InputsPropertyTabComponent extends React.Component<IInputsPropertyTabComponentProps> {
+    constructor(props: IInputsPropertyTabComponentProps);
+    processInputBlockUpdate(ib: InputBlock): void;
+    renderInputBlock(block: InputBlock): JSX.Element | null;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/components/propertyTab/properties/color3PropertyTabComponent" {
+import * as React from "react";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+import { InputBlock } from "babylonjs/Materials/Node/Blocks/Input/inputBlock";
+interface IColor3PropertyTabComponentProps {
+    globalState: GlobalState;
+    inputBlock: InputBlock;
+}
+export declare class Color3PropertyTabComponent extends React.Component<IColor3PropertyTabComponentProps> {
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/components/propertyTab/properties/color4PropertyTabComponent" {
+import * as React from "react";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+import { InputBlock } from "babylonjs/Materials/Node/Blocks/Input/inputBlock";
+interface IColor4PropertyTabComponentProps {
+    globalState: GlobalState;
+    inputBlock: InputBlock;
+}
+export declare class Color4PropertyTabComponent extends React.Component<IColor4PropertyTabComponentProps> {
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/components/propertyTab/properties/floatPropertyTabComponent" {
+import * as React from "react";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+import { InputBlock } from "babylonjs/Materials/Node/Blocks/Input/inputBlock";
+interface IFloatPropertyTabComponentProps {
+    globalState: GlobalState;
+    inputBlock: InputBlock;
+}
+export declare class FloatPropertyTabComponent extends React.Component<IFloatPropertyTabComponentProps> {
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/components/propertyTab/properties/matrixPropertyTabComponent" {
+import * as React from "react";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+import { InputBlock } from "babylonjs/Materials/Node/Blocks/Input/inputBlock";
+interface IMatrixPropertyTabComponentProps {
+    globalState: GlobalState;
+    inputBlock: InputBlock;
+}
+export declare class MatrixPropertyTabComponent extends React.Component<IMatrixPropertyTabComponentProps> {
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/components/propertyTab/properties/vector2PropertyTabComponent" {
+import * as React from "react";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+import { InputBlock } from "babylonjs/Materials/Node/Blocks/Input/inputBlock";
+interface IVector2PropertyTabComponentProps {
+    globalState: GlobalState;
+    inputBlock: InputBlock;
+}
+export declare class Vector2PropertyTabComponent extends React.Component<IVector2PropertyTabComponentProps> {
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/components/propertyTab/properties/vector3PropertyTabComponent" {
+import * as React from "react";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+import { InputBlock } from "babylonjs/Materials/Node/Blocks/Input/inputBlock";
+interface IVector3PropertyTabComponentProps {
+    globalState: GlobalState;
+    inputBlock: InputBlock;
+}
+export declare class Vector3PropertyTabComponent extends React.Component<IVector3PropertyTabComponentProps> {
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/components/propertyTab/properties/vector4PropertyTabComponent" {
+import * as React from "react";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+import { InputBlock } from "babylonjs/Materials/Node/Blocks/Input/inputBlock";
+interface IVector4PropertyTabComponentProps {
+    globalState: GlobalState;
+    inputBlock: InputBlock;
+}
+export declare class Vector4PropertyTabComponent extends React.Component<IVector4PropertyTabComponentProps> {
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/components/propertyTab/propertyTabComponent" {
+import * as React from "react";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+import { Nullable } from "babylonjs/types";
+import { GraphNode } from "babylonjs-node-editor/diagram/graphNode";
+import { GraphFrame } from "babylonjs-node-editor/diagram/graphFrame";
+import { InputBlock } from "babylonjs/Materials/Node/Blocks/Input/inputBlock";
+import { FrameNodePort } from "babylonjs-node-editor/diagram/frameNodePort";
+import { NodePort } from "babylonjs-node-editor/diagram/nodePort";
+interface IPropertyTabComponentProps {
+    globalState: GlobalState;
+}
+interface IPropertyTabComponentState {
+    currentNode: Nullable<GraphNode>;
+    currentFrame: Nullable<GraphFrame>;
+    currentFrameNodePort: Nullable<FrameNodePort>;
+    currentNodePort: Nullable<NodePort>;
+    uploadInProgress: boolean;
+}
+export declare class PropertyTabComponent extends React.Component<IPropertyTabComponentProps, IPropertyTabComponentState> {
+    private _onBuiltObserver;
+    private _modeSelect;
+    constructor(props: IPropertyTabComponentProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    processInputBlockUpdate(ib: InputBlock): void;
+    renderInputBlock(block: InputBlock): JSX.Element | null;
+    load(file: File): void;
+    loadFrame(file: File): void;
+    save(): void;
+    customSave(): void;
+    saveToSnippetServer(): void;
+    loadFromSnippet(): void;
+    changeMode(value: any, force?: boolean, loadDefault?: boolean): boolean;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/diagram/display/clampDisplayManager" {
+import { IDisplayManager } from "babylonjs-node-editor/diagram/display/displayManager";
+import { NodeMaterialBlock } from "babylonjs/Materials/Node/nodeMaterialBlock";
+export declare class ClampDisplayManager implements IDisplayManager {
+    getHeaderClass(block: NodeMaterialBlock): string;
+    shouldDisplayPortLabels(block: NodeMaterialBlock): boolean;
+    getHeaderText(block: NodeMaterialBlock): string;
+    getBackgroundColor(block: NodeMaterialBlock): string;
+    updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/display/conditionalDisplayManager" {
+import { IDisplayManager } from "babylonjs-node-editor/diagram/display/displayManager";
+import { NodeMaterialBlock } from "babylonjs/Materials/Node/nodeMaterialBlock";
+export declare class ConditionalDisplayManager implements IDisplayManager {
+    getHeaderClass(block: NodeMaterialBlock): string;
+    shouldDisplayPortLabels(block: NodeMaterialBlock): boolean;
+    getHeaderText(block: NodeMaterialBlock): string;
+    getBackgroundColor(block: NodeMaterialBlock): string;
+    updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/display/discardDisplayManager" {
+import { IDisplayManager } from "babylonjs-node-editor/diagram/display/displayManager";
+import { NodeMaterialBlock } from "babylonjs/Materials/Node/nodeMaterialBlock";
+export declare class DiscardDisplayManager implements IDisplayManager {
+    getHeaderClass(block: NodeMaterialBlock): string;
+    shouldDisplayPortLabels(block: NodeMaterialBlock): boolean;
+    getHeaderText(block: NodeMaterialBlock): string;
+    getBackgroundColor(block: NodeMaterialBlock): string;
+    updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/display/displayManager" {
+import { NodeMaterialBlock } from "babylonjs/Materials/Node/nodeMaterialBlock";
+export interface IDisplayManager {
+    getHeaderClass(block: NodeMaterialBlock): string;
+    shouldDisplayPortLabels(block: NodeMaterialBlock): boolean;
+    updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+    getBackgroundColor(block: NodeMaterialBlock): string;
+    getHeaderText(block: NodeMaterialBlock): string;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/display/elbowDisplayManager" {
+import { IDisplayManager } from "babylonjs-node-editor/diagram/display/displayManager";
+import { NodeMaterialBlock } from "babylonjs/Materials/Node/nodeMaterialBlock";
+export declare class ElbowDisplayManager implements IDisplayManager {
+    getHeaderClass(block: NodeMaterialBlock): string;
+    shouldDisplayPortLabels(block: NodeMaterialBlock): boolean;
+    getHeaderText(block: NodeMaterialBlock): string;
+    getBackgroundColor(block: NodeMaterialBlock): string;
+    updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/display/gradientDisplayManager" {
+import { IDisplayManager } from "babylonjs-node-editor/diagram/display/displayManager";
+import { NodeMaterialBlock } from "babylonjs/Materials/Node/nodeMaterialBlock";
+export declare class GradientDisplayManager implements IDisplayManager {
+    getHeaderClass(block: NodeMaterialBlock): string;
+    shouldDisplayPortLabels(block: NodeMaterialBlock): boolean;
+    getHeaderText(block: NodeMaterialBlock): string;
+    getBackgroundColor(block: NodeMaterialBlock): string;
+    updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/display/imageSourceDisplayManager" {
+import { IDisplayManager } from "babylonjs-node-editor/diagram/display/displayManager";
+import { NodeMaterialBlock } from "babylonjs/Materials/Node/nodeMaterialBlock";
+export declare class imageSourceDisplayManager implements IDisplayManager {
+    private _previewCanvas;
+    private _previewImage;
+    getHeaderClass(block: NodeMaterialBlock): string;
+    shouldDisplayPortLabels(block: NodeMaterialBlock): boolean;
+    getHeaderText(block: NodeMaterialBlock): string;
+    getBackgroundColor(block: NodeMaterialBlock): string;
+    updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/display/inputDisplayManager" {
+import { IDisplayManager } from "babylonjs-node-editor/diagram/display/displayManager";
+import { NodeMaterialBlock } from "babylonjs/Materials/Node/nodeMaterialBlock";
+import { NodeMaterialBlockConnectionPointTypes } from "babylonjs/Materials/Node/Enums/nodeMaterialBlockConnectionPointTypes";
+export declare class InputDisplayManager implements IDisplayManager {
+    getHeaderClass(block: NodeMaterialBlock): "" | "constant" | "inspector";
+    shouldDisplayPortLabels(block: NodeMaterialBlock): boolean;
+    getHeaderText(block: NodeMaterialBlock): string;
+    static GetBaseType(type: NodeMaterialBlockConnectionPointTypes): string;
+    getBackgroundColor(block: NodeMaterialBlock): string;
+    updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/display/outputDisplayManager" {
+import { IDisplayManager } from "babylonjs-node-editor/diagram/display/displayManager";
+import { NodeMaterialBlock } from "babylonjs/Materials/Node/nodeMaterialBlock";
+export declare class OutputDisplayManager implements IDisplayManager {
+    getHeaderClass(block: NodeMaterialBlock): string;
+    shouldDisplayPortLabels(block: NodeMaterialBlock): boolean;
+    getHeaderText(block: NodeMaterialBlock): string;
+    getBackgroundColor(block: NodeMaterialBlock): string;
+    updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/display/pbrDisplayManager" {
+import { IDisplayManager } from "babylonjs-node-editor/diagram/display/displayManager";
+import { NodeMaterialBlock } from "babylonjs/Materials/Node/nodeMaterialBlock";
+export declare class PBRDisplayManager implements IDisplayManager {
+    getHeaderClass(block: NodeMaterialBlock): string;
+    shouldDisplayPortLabels(block: NodeMaterialBlock): boolean;
+    getHeaderText(block: NodeMaterialBlock): string;
+    getBackgroundColor(block: NodeMaterialBlock): string;
+    updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/display/remapDisplayManager" {
+import { IDisplayManager } from "babylonjs-node-editor/diagram/display/displayManager";
+import { NodeMaterialBlock } from "babylonjs/Materials/Node/nodeMaterialBlock";
+export declare class RemapDisplayManager implements IDisplayManager {
+    getHeaderClass(block: NodeMaterialBlock): string;
+    shouldDisplayPortLabels(block: NodeMaterialBlock): boolean;
+    getHeaderText(block: NodeMaterialBlock): string;
+    getBackgroundColor(block: NodeMaterialBlock): string;
+    private _extractInputValue;
+    updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/display/textureDisplayManager" {
+import { IDisplayManager } from "babylonjs-node-editor/diagram/display/displayManager";
+import { NodeMaterialBlock } from "babylonjs/Materials/Node/nodeMaterialBlock";
+export declare class TextureDisplayManager implements IDisplayManager {
+    private _previewCanvas;
+    private _previewImage;
+    getHeaderClass(block: NodeMaterialBlock): string;
+    shouldDisplayPortLabels(block: NodeMaterialBlock): boolean;
+    getHeaderText(block: NodeMaterialBlock): string;
+    getBackgroundColor(block: NodeMaterialBlock): string;
+    updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/display/trigonometryDisplayManager" {
+import { IDisplayManager } from "babylonjs-node-editor/diagram/display/displayManager";
+import { NodeMaterialBlock } from "babylonjs/Materials/Node/nodeMaterialBlock";
+export declare class TrigonometryDisplayManager implements IDisplayManager {
+    getHeaderClass(block: NodeMaterialBlock): string;
+    shouldDisplayPortLabels(block: NodeMaterialBlock): boolean;
+    getHeaderText(block: NodeMaterialBlock): string;
+    getBackgroundColor(block: NodeMaterialBlock): string;
+    updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/displayLedger" {
+export declare class DisplayLedger {
+    static RegisteredControls: {
+        [key: string]: any;
+    };
+}
+
+}
+declare module "babylonjs-node-editor/diagram/frameNodePort" {
+import { NodePort } from "babylonjs-node-editor/diagram/nodePort";
+import { GraphNode } from "babylonjs-node-editor/diagram/graphNode";
+import { FramePortPosition } from "babylonjs-node-editor/diagram/graphFrame";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+import { IDisplayManager } from "babylonjs-node-editor/diagram/display/displayManager";
+import { Observable } from "babylonjs/Misc/observable";
+import { Nullable } from "babylonjs/types";
+import { NodeMaterialConnectionPoint } from "babylonjs/Materials/Node/nodeMaterialBlockConnectionPoint";
+export declare class FrameNodePort extends NodePort {
+    connectionPoint: NodeMaterialConnectionPoint;
+    node: GraphNode;
+    private _parentFrameId;
+    private _isInput;
+    private _framePortPosition;
+    private _framePortId;
+    private _onFramePortPositionChangedObservable;
+    get parentFrameId(): number;
+    get onFramePortPositionChangedObservable(): Observable<FrameNodePort>;
+    get isInput(): boolean;
+    get framePortId(): number;
+    get framePortPosition(): FramePortPosition;
+    set framePortPosition(position: FramePortPosition);
+    constructor(portContainer: HTMLElement, connectionPoint: NodeMaterialConnectionPoint, node: GraphNode, globalState: GlobalState, isInput: boolean, framePortId: number, parentFrameId: number);
+    static CreateFrameNodePortElement(connectionPoint: NodeMaterialConnectionPoint, node: GraphNode, root: HTMLElement, displayManager: Nullable<IDisplayManager>, globalState: GlobalState, isInput: boolean, framePortId: number, parentFrameId: number): FrameNodePort;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/graphCanvas" {
+import * as React from "react";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+import { NodeMaterialBlock } from "babylonjs/Materials/Node/nodeMaterialBlock";
+import { GraphNode } from "babylonjs-node-editor/diagram/graphNode";
+import { Nullable } from "babylonjs/types";
+import { NodeLink } from "babylonjs-node-editor/diagram/nodeLink";
+import { NodePort } from "babylonjs-node-editor/diagram/nodePort";
+import { NodeMaterialConnectionPoint } from "babylonjs/Materials/Node/nodeMaterialBlockConnectionPoint";
+import { GraphFrame } from "babylonjs-node-editor/diagram/graphFrame";
+import { IEditorData, IFrameData } from "babylonjs-node-editor/nodeLocationInfo";
+import { FrameNodePort } from "babylonjs-node-editor/diagram/frameNodePort";
+import "babylonjs-node-editor/diagram/graphCanvas.scss";
+export interface IGraphCanvasComponentProps {
+    globalState: GlobalState;
+    onEmitNewBlock: (block: NodeMaterialBlock) => GraphNode;
+}
+export declare type FramePortData = {
+    frame: GraphFrame;
+    port: FrameNodePort;
+};
+export declare const isFramePortData: (variableToCheck: any) => variableToCheck is FramePortData;
+export declare class GraphCanvasComponent extends React.Component<IGraphCanvasComponentProps> {
+    private readonly MinZoom;
+    private readonly MaxZoom;
+    private _hostCanvas;
+    private _graphCanvas;
+    private _selectionContainer;
+    private _frameContainer;
+    private _svgCanvas;
+    private _rootContainer;
+    private _nodes;
+    private _links;
+    private _mouseStartPointX;
+    private _mouseStartPointY;
+    private _dropPointX;
+    private _dropPointY;
+    private _selectionStartX;
+    private _selectionStartY;
+    private _candidateLinkedHasMoved;
+    private _x;
+    private _y;
+    private _zoom;
+    private _selectedNodes;
+    private _selectedLink;
+    private _selectedPort;
+    private _candidateLink;
+    private _candidatePort;
+    private _gridSize;
+    private _selectionBox;
+    private _selectedFrame;
+    private _frameCandidate;
+    private _frames;
+    private _altKeyIsPressed;
+    private _ctrlKeyIsPressed;
+    private _oldY;
+    _frameIsMoving: boolean;
+    _isLoading: boolean;
+    get gridSize(): number;
+    set gridSize(value: number);
+    get globalState(): GlobalState;
+    get nodes(): GraphNode[];
+    get links(): NodeLink[];
+    get frames(): GraphFrame[];
+    get zoom(): number;
+    set zoom(value: number);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get selectedNodes(): GraphNode[];
+    get selectedLink(): Nullable<NodeLink>;
+    get selectedFrame(): Nullable<GraphFrame>;
+    get selectedPort(): Nullable<NodePort>;
+    get canvasContainer(): HTMLDivElement;
+    get hostCanvas(): HTMLDivElement;
+    get svgCanvas(): HTMLElement;
+    get selectionContainer(): HTMLDivElement;
+    get frameContainer(): HTMLDivElement;
+    constructor(props: IGraphCanvasComponentProps);
+    static _RefreshNode: (node: GraphNode, visitedNodes?: Set<GraphNode> | undefined, visitedLinks?: Set<NodeLink> | undefined) => void;
+    getGridPosition(position: number, useCeil?: boolean): number;
+    getGridPositionCeil(position: number): number;
+    updateTransform(): void;
+    onKeyUp(): void;
+    findNodeFromBlock(block: NodeMaterialBlock): GraphNode;
+    reset(): void;
+    connectPorts(pointA: NodeMaterialConnectionPoint, pointB: NodeMaterialConnectionPoint): void;
+    removeLink(link: NodeLink): void;
+    appendBlock(block: NodeMaterialBlock): GraphNode;
+    distributeGraph(): void;
+    componentDidMount(): void;
+    onMove(evt: React.PointerEvent): void;
+    onDown(evt: React.PointerEvent<HTMLElement>): void;
+    onUp(evt: React.PointerEvent): void;
+    onWheel(evt: React.WheelEvent): void;
+    zoomToFit(): void;
+    processCandidatePort(): void;
+    processEditorData(editorData: IEditorData): void;
+    addFrame(frameData: IFrameData): void;
+    render(): JSX.Element;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/graphFrame" {
+import { GraphNode } from "babylonjs-node-editor/diagram/graphNode";
+import { GraphCanvasComponent } from "babylonjs-node-editor/diagram/graphCanvas";
+import { Nullable } from "babylonjs/types";
+import { Observable } from "babylonjs/Misc/observable";
+import { IFrameData } from "babylonjs-node-editor/nodeLocationInfo";
+import { Color3 } from "babylonjs/Maths/math.color";
+import { FrameNodePort } from "babylonjs-node-editor/diagram/frameNodePort";
+export declare enum FramePortPosition {
+    Top = 0,
+    Middle = 1,
+    Bottom = 2
+}
+export declare class GraphFrame {
+    private readonly CollapsedWidth;
+    private static _FrameCounter;
+    private static _FramePortCounter;
+    private _name;
+    private _color;
+    private _x;
+    private _y;
+    private _gridAlignedX;
+    private _gridAlignedY;
+    private _width;
+    private _height;
+    element: HTMLDivElement;
+    private _borderElement;
+    private _headerElement;
+    private _headerTextElement;
+    private _headerCollapseElement;
+    private _headerCloseElement;
+    private _commentsElement;
+    private _portContainer;
+    private _outputPortContainer;
+    private _inputPortContainer;
+    private _nodes;
+    private _ownerCanvas;
+    private _mouseStartPointX;
+    private _mouseStartPointY;
+    private _onSelectionChangedObserver;
+    private _onGraphNodeRemovalObserver;
+    private _onExposePortOnFrameObserver;
+    private _onNodeLinkDisposedObservers;
+    private _isCollapsed;
+    private _frameInPorts;
+    private _frameOutPorts;
+    private _controlledPorts;
+    private _exposedInPorts;
+    private _exposedOutPorts;
+    private _id;
+    private _comments;
+    private _frameIsResizing;
+    private _resizingDirection;
+    private _minFrameHeight;
+    private _minFrameWidth;
+    private mouseXLimit;
+    onExpandStateChanged: Observable<GraphFrame>;
+    private readonly CloseSVG;
+    private readonly ExpandSVG;
+    private readonly CollapseSVG;
+    get id(): number;
+    get isCollapsed(): boolean;
+    private _createInputPort;
+    private _markFramePortPositions;
+    private _createFramePorts;
+    private removePortFromExposedWithNode;
+    private removePortFromExposedWithLink;
+    private createInputPorts;
+    private createOutputPorts;
+    redrawFramePorts(): void;
+    set isCollapsed(value: boolean);
+    get nodes(): GraphNode[];
+    get ports(): FrameNodePort[];
+    get name(): string;
+    set name(value: string);
+    get color(): Color3;
+    set color(value: Color3);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get width(): number;
+    set width(value: number);
+    get height(): number;
+    set height(value: number);
+    get comments(): string;
+    set comments(comments: string);
+    constructor(candidate: Nullable<HTMLDivElement>, canvas: GraphCanvasComponent, doNotCaptureNodes?: boolean);
+    refresh(): void;
+    addNode(node: GraphNode): void;
+    removeNode(node: GraphNode): void;
+    syncNode(node: GraphNode): void;
+    cleanAccumulation(): void;
+    private _onDown;
+    move(newX: number, newY: number, align?: boolean): void;
+    private _onUp;
+    private _moveFrame;
+    private _onMove;
+    moveFramePortUp(nodePort: FrameNodePort): void;
+    private _movePortUp;
+    moveFramePortDown(nodePort: FrameNodePort): void;
+    private _movePortDown;
+    private initResizing;
+    private cleanUpResizing;
+    private updateMinHeightWithComments;
+    private _isResizingTop;
+    private _isResizingRight;
+    private _isResizingBottom;
+    private _isResizingLeft;
+    private _onRightHandlePointerDown;
+    private _onRightHandlePointerMove;
+    private _moveRightHandle;
+    private _onRightHandlePointerUp;
+    private _onBottomHandlePointerDown;
+    private _onBottomHandlePointerMove;
+    private _moveBottomHandle;
+    private _onBottomHandlePointerUp;
+    private _onLeftHandlePointerDown;
+    private _onLeftHandlePointerMove;
+    private _moveLeftHandle;
+    private _onLeftHandlePointerUp;
+    private _onTopHandlePointerDown;
+    private _onTopHandlePointerMove;
+    private _moveTopHandle;
+    private _onTopHandlePointerUp;
+    private _onTopRightHandlePointerDown;
+    private _onTopRightHandlePointerMove;
+    private _moveTopRightHandle;
+    private _onTopRightHandlePointerUp;
+    private _onBottomRightHandlePointerDown;
+    private _onBottomRightHandlePointerMove;
+    private _moveBottomRightHandle;
+    private _onBottomRightHandlePointerUp;
+    private _onBottomLeftHandlePointerDown;
+    private _onBottomLeftHandlePointerMove;
+    private _moveBottomLeftHandle;
+    private _onBottomLeftHandlePointerUp;
+    private _onTopLeftHandlePointerDown;
+    private _onTopLeftHandlePointerMove;
+    private _moveTopLeftHandle;
+    private _onTopLeftHandlePointerUp;
+    private _expandLeft;
+    private _expandTop;
+    private _expandRight;
+    private _expandBottom;
+    dispose(): void;
+    private serializePortData;
+    serialize(saveCollapsedState: boolean): IFrameData;
+    export(): void;
+    adjustPorts(): void;
+    static Parse(serializationData: IFrameData, canvas: GraphCanvasComponent, map?: {
+        [key: number]: number;
+    }): GraphFrame;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/graphNode" {
+/// <reference types="react" />
+import { NodeMaterialBlock } from "babylonjs/Materials/Node/nodeMaterialBlock";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+import { Nullable } from "babylonjs/types";
+import { NodeMaterialConnectionPoint } from "babylonjs/Materials/Node/nodeMaterialBlockConnectionPoint";
+import { GraphCanvasComponent } from "babylonjs-node-editor/diagram/graphCanvas";
+import { NodeLink } from "babylonjs-node-editor/diagram/nodeLink";
+import { NodePort } from "babylonjs-node-editor/diagram/nodePort";
+import { GraphFrame } from "babylonjs-node-editor/diagram/graphFrame";
+export declare class GraphNode {
+    block: NodeMaterialBlock;
+    private _visual;
+    private _headerContainer;
+    private _promotionWarning;
+    private _header;
+    private _connections;
+    private _inputsContainer;
+    private _outputsContainer;
+    private _content;
+    private _comments;
+    private _inputPorts;
+    private _outputPorts;
+    private _links;
+    private _x;
+    private _y;
+    private _gridAlignedX;
+    private _gridAlignedY;
+    private _mouseStartPointX;
+    private _mouseStartPointY;
+    private _globalState;
+    private _onSelectionChangedObserver;
+    private _onSelectionBoxMovedObserver;
+    private _onFrameCreatedObserver;
+    private _onUpdateRequiredObserver;
+    private _ownerCanvas;
+    private _isSelected;
+    private _displayManager;
+    private _isVisible;
+    private _enclosingFrameId;
+    get isVisible(): boolean;
+    set isVisible(value: boolean);
+    private _upateNodePortNames;
+    get outputPorts(): NodePort[];
+    get inputPorts(): NodePort[];
+    get links(): NodeLink[];
+    get gridAlignedX(): number;
+    get gridAlignedY(): number;
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get width(): number;
+    get height(): number;
+    get id(): number;
+    get name(): string;
+    get isSelected(): boolean;
+    get enclosingFrameId(): number;
+    set enclosingFrameId(value: number);
+    set isSelected(value: boolean);
+    constructor(block: NodeMaterialBlock, globalState: GlobalState);
+    isOverlappingFrame(frame: GraphFrame): boolean;
+    getPortForConnectionPoint(point: NodeMaterialConnectionPoint): NodePort | null;
+    getLinksForConnectionPoint(point: NodeMaterialConnectionPoint): NodeLink[];
+    private _refreshFrames;
+    _refreshLinks(): void;
+    refresh(): void;
+    private _onDown;
+    cleanAccumulation(useCeil?: boolean): void;
+    private _onUp;
+    private _onMove;
+    renderProperties(): Nullable<JSX.Element>;
+    appendVisual(root: HTMLDivElement, owner: GraphCanvasComponent): void;
+    dispose(): void;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/nodeLink" {
+import { GraphCanvasComponent } from "babylonjs-node-editor/diagram/graphCanvas";
+import { GraphNode } from "babylonjs-node-editor/diagram/graphNode";
+import { NodePort } from "babylonjs-node-editor/diagram/nodePort";
+import { Observable } from "babylonjs/Misc/observable";
+import { FrameNodePort } from "babylonjs-node-editor/diagram/frameNodePort";
+export declare class NodeLink {
+    private _graphCanvas;
+    private _portA;
+    private _portB?;
+    private _nodeA;
+    private _nodeB?;
+    private _path;
+    private _selectionPath;
+    private _onSelectionChangedObserver;
+    private _isVisible;
+    onDisposedObservable: Observable<NodeLink>;
+    get isVisible(): boolean;
+    set isVisible(value: boolean);
+    get portA(): NodePort | FrameNodePort;
+    get portB(): NodePort | FrameNodePort | undefined;
+    get nodeA(): GraphNode;
+    get nodeB(): GraphNode | undefined;
+    update(endX?: number, endY?: number, straight?: boolean): void;
+    constructor(graphCanvas: GraphCanvasComponent, portA: NodePort, nodeA: GraphNode, portB?: NodePort, nodeB?: GraphNode);
+    onClick(): void;
+    dispose(notify?: boolean): void;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/nodePort" {
+import { NodeMaterialConnectionPoint } from "babylonjs/Materials/Node/nodeMaterialBlockConnectionPoint";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+import { Nullable } from "babylonjs/types";
+import { Observer } from "babylonjs/Misc/observable";
+import { Vector2 } from "babylonjs/Maths/math.vector";
+import { IDisplayManager } from "babylonjs-node-editor/diagram/display/displayManager";
+import { GraphNode } from "babylonjs-node-editor/diagram/graphNode";
+import { NodeLink } from "babylonjs-node-editor/diagram/nodeLink";
+import { GraphFrame } from "babylonjs-node-editor/diagram/graphFrame";
+import { FrameNodePort } from "babylonjs-node-editor/diagram/frameNodePort";
+import { FramePortData } from "babylonjs-node-editor/diagram/graphCanvas";
+export declare class NodePort {
+    connectionPoint: NodeMaterialConnectionPoint;
+    node: GraphNode;
+    protected _element: HTMLDivElement;
+    protected _img: HTMLImageElement;
+    protected _globalState: GlobalState;
+    protected _portLabelElement: Element;
+    protected _onCandidateLinkMovedObserver: Nullable<Observer<Nullable<Vector2>>>;
+    protected _onSelectionChangedObserver: Nullable<Observer<Nullable<GraphFrame | GraphNode | NodeLink | NodePort | FramePortData>>>;
+    protected _exposedOnFrame: boolean;
+    delegatedPort: Nullable<FrameNodePort>;
+    get element(): HTMLDivElement;
+    get portName(): string;
+    set portName(newName: string);
+    get disabled(): boolean;
+    hasLabel(): boolean;
+    get exposedOnFrame(): boolean;
+    set exposedOnFrame(value: boolean);
+    get exposedPortPosition(): number;
+    set exposedPortPosition(value: number);
+    private _isConnectedToNodeOutsideOfFrame;
+    refresh(): void;
+    constructor(portContainer: HTMLElement, connectionPoint: NodeMaterialConnectionPoint, node: GraphNode, globalState: GlobalState);
+    dispose(): void;
+    static CreatePortElement(connectionPoint: NodeMaterialConnectionPoint, node: GraphNode, root: HTMLElement, displayManager: Nullable<IDisplayManager>, globalState: GlobalState): NodePort;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/properties/colorMergerPropertyComponent" {
+import * as React from "react";
+import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
+export declare class ColorMergerPropertyTabComponent extends React.Component<IPropertyComponentProps> {
+    constructor(props: IPropertyComponentProps);
+    render(): JSX.Element;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/properties/conditionalNodePropertyComponent" {
+import * as React from "react";
+import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
+export declare class ConditionalPropertyTabComponent extends React.Component<IPropertyComponentProps> {
+    constructor(props: IPropertyComponentProps);
+    render(): JSX.Element;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/properties/frameNodePortPropertyComponent" {
+import * as React from "react";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+import { GraphFrame } from "babylonjs-node-editor/diagram/graphFrame";
+import { FrameNodePort } from "babylonjs-node-editor/diagram/frameNodePort";
+export interface IFrameNodePortPropertyTabComponentProps {
+    globalState: GlobalState;
+    frameNodePort: FrameNodePort;
+    frame: GraphFrame;
+}
+export declare class FrameNodePortPropertyTabComponent extends React.Component<IFrameNodePortPropertyTabComponentProps, {
+    port: FrameNodePort;
+}> {
+    private _onFramePortPositionChangedObserver;
+    private _onSelectionChangedObserver;
+    constructor(props: IFrameNodePortPropertyTabComponentProps);
+    componentWillUnmount(): void;
+    render(): JSX.Element;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/properties/framePropertyComponent" {
+import * as React from "react";
+import { GraphFrame } from "babylonjs-node-editor/diagram/graphFrame";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+export interface IFramePropertyTabComponentProps {
+    globalState: GlobalState;
+    frame: GraphFrame;
+}
+export declare class FramePropertyTabComponent extends React.Component<IFramePropertyTabComponentProps> {
+    private onFrameExpandStateChangedObserver;
+    constructor(props: IFramePropertyTabComponentProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    render(): JSX.Element;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/properties/genericNodePropertyComponent" {
+import * as React from "react";
+import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
+import { Scene } from "babylonjs/scene";
+export declare class GenericPropertyComponent extends React.Component<IPropertyComponentProps> {
+    constructor(props: IPropertyComponentProps);
+    render(): JSX.Element;
+}
+export declare class GeneralPropertyTabComponent extends React.Component<IPropertyComponentProps> {
+    constructor(props: IPropertyComponentProps);
+    render(): JSX.Element;
+}
+export declare class GenericPropertyTabComponent extends React.Component<IPropertyComponentProps> {
+    constructor(props: IPropertyComponentProps);
+    forceRebuild(notifiers?: {
+        rebuild?: boolean;
+        update?: boolean;
+        activatePreviewCommand?: boolean;
+        callback?: (scene: Scene) => void;
+    }): void;
+    render(): JSX.Element;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/properties/gradientNodePropertyComponent" {
+import * as React from "react";
+import { GradientBlockColorStep } from "babylonjs/Materials/Node/Blocks/gradientBlock";
+import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
+export declare class GradientPropertyTabComponent extends React.Component<IPropertyComponentProps> {
+    private onValueChangedObserver;
+    constructor(props: IPropertyComponentProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    forceRebuild(): void;
+    deleteStep(step: GradientBlockColorStep): void;
+    copyStep(step: GradientBlockColorStep): void;
+    addNewStep(): void;
+    checkForReOrder(): void;
+    render(): JSX.Element;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/properties/gradientStepComponent" {
+import * as React from "react";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+import { GradientBlockColorStep } from "babylonjs/Materials/Node/Blocks/gradientBlock";
+interface IGradientStepComponentProps {
+    globalState: GlobalState;
+    step: GradientBlockColorStep;
+    lineIndex: number;
+    onDelete: () => void;
+    onUpdateStep: () => void;
+    onCheckForReOrder: () => void;
+    onCopy?: () => void;
+}
+export declare class GradientStepComponent extends React.Component<IGradientStepComponentProps, {
+    gradient: number;
+}> {
+    constructor(props: IGradientStepComponentProps);
+    updateColor(color: string): void;
+    updateStep(gradient: number): void;
+    onPointerUp(): void;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/diagram/properties/imageSourcePropertyTabComponent" {
+import * as React from "react";
+import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
+import { ImageSourceBlock } from "babylonjs/Materials/Node/Blocks/Dual/imageSourceBlock";
+export declare class ImageSourcePropertyTabComponent extends React.Component<IPropertyComponentProps, {
+    isEmbedded: boolean;
+}> {
+    get imageSourceBlock(): ImageSourceBlock;
+    constructor(props: IPropertyComponentProps);
+    UNSAFE_componentWillUpdate(nextProps: IPropertyComponentProps, nextState: {
+        isEmbedded: boolean;
+        loadAsCubeTexture: boolean;
+    }): void;
+    private _generateRandomForCache;
+    updateAfterTextureLoad(): void;
+    removeTexture(): void;
+    _prepareTexture(): void;
+    /**
+     * Replaces the texture of the node
+     * @param file the file of the texture to use
+     */
+    replaceTexture(file: File): void;
+    replaceTextureWithUrl(url: string): void;
+    render(): JSX.Element;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/properties/inputNodePropertyComponent" {
+import * as React from "react";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
+export declare class InputPropertyTabComponent extends React.Component<IPropertyComponentProps> {
+    private onValueChangedObserver;
+    constructor(props: IPropertyComponentProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    renderValue(globalState: GlobalState): JSX.Element | null;
+    setDefaultValue(): void;
+    render(): JSX.Element;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/properties/lightInformationPropertyTabComponent" {
+import * as React from "react";
+import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
+export declare class LightInformationPropertyTabComponent extends React.Component<IPropertyComponentProps> {
+    render(): JSX.Element;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/properties/lightPropertyTabComponent" {
+import * as React from "react";
+import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
+export declare class LightPropertyTabComponent extends React.Component<IPropertyComponentProps> {
+    render(): JSX.Element;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/properties/nodePortPropertyComponent" {
+import * as React from "react";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+import { NodePort } from "babylonjs-node-editor/diagram/nodePort";
+export interface IFrameNodePortPropertyTabComponentProps {
+    globalState: GlobalState;
+    nodePort: NodePort;
+}
+export declare class NodePortPropertyTabComponent extends React.Component<IFrameNodePortPropertyTabComponentProps> {
+    private _onSelectionChangedObserver;
+    constructor(props: IFrameNodePortPropertyTabComponentProps);
+    componentWillUnmount(): void;
+    toggleExposeOnFrame(value: boolean): void;
+    render(): JSX.Element;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/properties/propertyComponentProps" {
+import { GlobalState } from "babylonjs-node-editor/globalState";
+import { NodeMaterialBlock } from "babylonjs/Materials/Node/nodeMaterialBlock";
+export interface IPropertyComponentProps {
+    globalState: GlobalState;
+    block: NodeMaterialBlock;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/properties/texturePropertyTabComponent" {
+import * as React from "react";
+import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
+import { ReflectionTextureBlock } from "babylonjs/Materials/Node/Blocks/Dual/reflectionTextureBlock";
+import { ReflectionBlock } from "babylonjs/Materials/Node/Blocks/PBR/reflectionBlock";
+import { RefractionBlock } from "babylonjs/Materials/Node/Blocks/PBR/refractionBlock";
+import { TextureBlock } from "babylonjs/Materials/Node/Blocks/Dual/textureBlock";
+import { CurrentScreenBlock } from "babylonjs/Materials/Node/Blocks/Dual/currentScreenBlock";
+import { ParticleTextureBlock } from "babylonjs/Materials/Node/Blocks/Particle/particleTextureBlock";
+declare type ReflectionTexture = ReflectionTextureBlock | ReflectionBlock | RefractionBlock;
+declare type AnyTexture = TextureBlock | ReflectionTexture | CurrentScreenBlock | ParticleTextureBlock;
+export declare class TexturePropertyTabComponent extends React.Component<IPropertyComponentProps, {
+    isEmbedded: boolean;
+    loadAsCubeTexture: boolean;
+    textureIsPrefiltered: boolean;
+}> {
+    get textureBlock(): AnyTexture;
+    constructor(props: IPropertyComponentProps);
+    UNSAFE_componentWillUpdate(nextProps: IPropertyComponentProps, nextState: {
+        isEmbedded: boolean;
+        loadAsCubeTexture: boolean;
+    }): void;
+    private _generateRandomForCache;
+    updateAfterTextureLoad(): void;
+    removeTexture(): void;
+    _prepareTexture(): void;
+    /**
+     * Replaces the texture of the node
+     * @param file the file of the texture to use
+     */
+    replaceTexture(file: File): void;
+    replaceTextureWithUrl(url: string): void;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/diagram/properties/transformNodePropertyComponent" {
+import * as React from "react";
+import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
+export declare class TransformPropertyTabComponent extends React.Component<IPropertyComponentProps> {
+    constructor(props: IPropertyComponentProps);
+    render(): JSX.Element;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/properties/trigonometryNodePropertyComponent" {
+import * as React from "react";
+import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
+export declare class TrigonometryPropertyTabComponent extends React.Component<IPropertyComponentProps> {
+    constructor(props: IPropertyComponentProps);
+    render(): JSX.Element;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/properties/vectorMergerPropertyComponent" {
+import * as React from "react";
+import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
+export declare class VectorMergerPropertyTabComponent extends React.Component<IPropertyComponentProps> {
+    constructor(props: IPropertyComponentProps);
+    render(): JSX.Element;
+}
+
+}
+declare module "babylonjs-node-editor/diagram/propertyLedger" {
+import { ComponentClass } from "react";
+import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
+export declare class PropertyLedger {
+    static RegisteredControls: {
+        [key: string]: ComponentClass<IPropertyComponentProps>;
+    };
+}
+
+}
+declare module "babylonjs-node-editor/globalState" {
+import { NodeMaterial } from "babylonjs/Materials/Node/nodeMaterial";
+import { Nullable } from "babylonjs/types";
+import { Observable } from "babylonjs/Misc/observable";
+import { LogEntry } from "babylonjs-node-editor/components/log/logComponent";
+import { NodeMaterialBlock } from "babylonjs/Materials/Node/nodeMaterialBlock";
+import { PreviewType } from "babylonjs-node-editor/components/preview/previewType";
+import { Color4 } from "babylonjs/Maths/math.color";
+import { GraphNode } from "babylonjs-node-editor/diagram/graphNode";
+import { Vector2 } from "babylonjs/Maths/math.vector";
+import { NodePort } from "babylonjs-node-editor/diagram/nodePort";
+import { NodeLink } from "babylonjs-node-editor/diagram/nodeLink";
+import { GraphFrame } from "babylonjs-node-editor/diagram/graphFrame";
+import { FrameNodePort } from "babylonjs-node-editor/diagram/frameNodePort";
+import { FramePortData } from "babylonjs-node-editor/diagram/graphCanvas";
+import { NodeMaterialModes } from "babylonjs/Materials/Node/Enums/nodeMaterialModes";
+export declare class GlobalState {
+    nodeMaterial: NodeMaterial;
+    hostElement: HTMLElement;
+    hostDocument: HTMLDocument;
+    hostWindow: Window;
+    onSelectionChangedObservable: Observable<Nullable<GraphFrame | GraphNode | NodePort | NodeLink | FramePortData>>;
+    onRebuildRequiredObservable: Observable<boolean>;
+    onBuiltObservable: Observable<void>;
+    onResetRequiredObservable: Observable<void>;
+    onUpdateRequiredObservable: Observable<Nullable<NodeMaterialBlock>>;
+    onZoomToFitRequiredObservable: Observable<void>;
+    onReOrganizedRequiredObservable: Observable<void>;
+    onLogRequiredObservable: Observable<LogEntry>;
+    onErrorMessageDialogRequiredObservable: Observable<string>;
+    onIsLoadingChanged: Observable<boolean>;
+    onPreviewCommandActivated: Observable<boolean>;
+    onLightUpdated: Observable<void>;
+    onPreviewBackgroundChanged: Observable<void>;
+    onBackFaceCullingChanged: Observable<void>;
+    onDepthPrePassChanged: Observable<void>;
+    onAnimationCommandActivated: Observable<void>;
+    onCandidateLinkMoved: Observable<Nullable<Vector2>>;
+    onSelectionBoxMoved: Observable<ClientRect | DOMRect>;
+    onFrameCreatedObservable: Observable<GraphFrame>;
+    onCandidatePortSelectedObservable: Observable<Nullable<NodePort | FrameNodePort>>;
+    onImportFrameObservable: Observable<any>;
+    onGraphNodeRemovalObservable: Observable<GraphNode>;
+    onPopupClosedObservable: Observable<void>;
+    onGetNodeFromBlock: (block: NodeMaterialBlock) => GraphNode;
+    onGridSizeChanged: Observable<void>;
+    onExposePortOnFrameObservable: Observable<GraphNode>;
+    previewType: PreviewType;
+    previewFile: File;
+    particleSystemBlendMode: number;
+    listOfCustomPreviewFiles: File[];
+    rotatePreview: boolean;
+    backgroundColor: Color4;
+    backFaceCulling: boolean;
+    depthPrePass: boolean;
+    blockKeyboardEvents: boolean;
+    hemisphericLight: boolean;
+    directionalLight0: boolean;
+    directionalLight1: boolean;
+    controlCamera: boolean;
+    storeEditorData: (serializationObject: any, frame?: Nullable<GraphFrame>) => void;
+    _mode: NodeMaterialModes;
+    /** Gets the mode */
+    get mode(): NodeMaterialModes;
+    /** Sets the mode */
+    set mode(m: NodeMaterialModes);
+    customSave?: {
+        label: string;
+        action: (data: string) => Promise<void>;
+    };
+    constructor();
+}
+
+}
+declare module "babylonjs-node-editor/graphEditor" {
+import * as React from "react";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+import { NodeMaterialBlock } from "babylonjs/Materials/Node/nodeMaterialBlock";
+import { Nullable } from "babylonjs/types";
+import { IEditorData } from "babylonjs-node-editor/nodeLocationInfo";
+import { GraphNode } from "babylonjs-node-editor/diagram/graphNode";
+import { IInspectorOptions } from "babylonjs/Debug/debugLayer";
+interface IGraphEditorProps {
+    globalState: GlobalState;
+}
+interface IGraphEditorState {
+    showPreviewPopUp: boolean;
+}
+interface IInternalPreviewAreaOptions extends IInspectorOptions {
+    popup: boolean;
+    original: boolean;
+    explorerWidth?: string;
+    inspectorWidth?: string;
+    embedHostWidth?: string;
+}
+export declare class GraphEditor extends React.Component<IGraphEditorProps, IGraphEditorState> {
+    private readonly NodeWidth;
+    private _graphCanvas;
+    private _startX;
+    private _moveInProgress;
+    private _leftWidth;
+    private _rightWidth;
+    private _blocks;
+    private _previewManager;
+    private _copiedNodes;
+    private _copiedFrame;
+    private _mouseLocationX;
+    private _mouseLocationY;
+    private _onWidgetKeyUpPointer;
+    private _previewHost;
+    private _popUpWindow;
+    /**
+     * Creates a node and recursivly creates its parent nodes from it's input
+     * @param nodeMaterialBlock
+     */
+    createNodeFromObject(block: NodeMaterialBlock, recursion?: boolean): GraphNode;
+    addValueNode(type: string): GraphNode;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    constructor(props: IGraphEditorProps);
+    reconnectNewNodes(nodeIndex: number, newNodes: GraphNode[], sourceNodes: GraphNode[], done: boolean[]): void;
+    pasteSelection(copiedNodes: GraphNode[], currentX: number, currentY: number, selectNew?: boolean): GraphNode[] | undefined;
+    zoomToFit(): void;
+    buildMaterial(autoConfigure?: boolean): void;
+    build(): void;
+    loadGraph(): void;
+    showWaitScreen(): void;
+    hideWaitScreen(): void;
+    reOrganize(editorData?: Nullable<IEditorData>, isImportingAFrame?: boolean): void;
+    onPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
+    onPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
+    resizeColumns(evt: React.PointerEvent<HTMLDivElement>, forLeft?: boolean): void;
+    buildColumnLayout(): string;
+    emitNewBlock(event: React.DragEvent<HTMLDivElement>): void;
+    handlePopUp: () => void;
+    handleClosingPopUp: () => void;
+    initiatePreviewArea: (canvas?: HTMLCanvasElement) => void;
+    createPopUp: () => void;
+    createPopupWindow: (title: string, windowVariableName: string, width?: number, height?: number) => Window | null;
+    createPreviewMeshControlHost: (options: IInternalPreviewAreaOptions, parentControl: Nullable<HTMLElement>) => void;
+    createPreviewHost: (options: IInternalPreviewAreaOptions, parentControl: Nullable<HTMLElement>) => void;
+    fixPopUpStyles: (document: Document) => void;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/index" {
+export * from "babylonjs-node-editor/nodeEditor";
+
+}
+declare module "babylonjs-node-editor/legacy/legacy" {
+export * from "babylonjs-node-editor/index";
+
+}
+declare module "babylonjs-node-editor/nodeEditor" {
+import { NodeMaterial } from "babylonjs/Materials/Node/nodeMaterial";
+import { Observable } from "babylonjs/Misc/observable";
+/**
+ * Interface used to specify creation options for the node editor
+ */
+export interface INodeEditorOptions {
+    nodeMaterial: NodeMaterial;
+    hostElement?: HTMLElement;
+    customSave?: {
+        label: string;
+        action: (data: string) => Promise<void>;
+    };
+    customLoadObservable?: Observable<any>;
+}
+/**
+ * Class used to create a node editor
+ */
+export declare class NodeEditor {
+    private static _CurrentState;
+    /**
+     * Show the node editor
+     * @param options defines the options to use to configure the node editor
+     */
+    static Show(options: INodeEditorOptions): void;
+}
+
+}
+declare module "babylonjs-node-editor/nodeLocationInfo" {
+export interface INodeLocationInfo {
+    blockId: number;
+    x: number;
+    y: number;
+}
+export interface IFrameData {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    color: number[];
+    name: string;
+    isCollapsed: boolean;
+    blocks: number[];
+    comments: string;
+}
+export interface IEditorData {
+    locations: INodeLocationInfo[];
+    x: number;
+    y: number;
+    zoom: number;
+    frames?: IFrameData[];
+    map?: {
+        [key: number]: number;
+    };
+}
+
+}
+declare module "babylonjs-node-editor/portal" {
+import * as React from "react";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+interface IPortalProps {
+    globalState: GlobalState;
+}
+export declare class Portal extends React.Component<IPortalProps> {
+    render(): React.ReactPortal;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/serializationTools" {
+import { NodeMaterial } from "babylonjs/Materials/Node/nodeMaterial";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+import { Nullable } from "babylonjs/types";
+import { GraphFrame } from "babylonjs-node-editor/diagram/graphFrame";
+export declare class SerializationTools {
+    static UpdateLocations(material: NodeMaterial, globalState: GlobalState, frame?: Nullable<GraphFrame>): void;
+    static Serialize(material: NodeMaterial, globalState: GlobalState, frame?: Nullable<GraphFrame>): string;
+    static Deserialize(serializationObject: any, globalState: GlobalState): void;
+    static AddFrameToMaterial(serializationObject: any, globalState: GlobalState, currentMaterial: NodeMaterial): void;
+}
+
+}
+declare module "babylonjs-node-editor/sharedComponents/buttonLineComponent" {
+import * as React from "react";
+export interface IButtonLineComponentProps {
+    label: string;
+    onClick: () => void;
+    isDisabled?: boolean;
+}
+export declare class ButtonLineComponent extends React.Component<IButtonLineComponentProps> {
+    constructor(props: IButtonLineComponentProps);
+    render(): JSX.Element;
+}
+
+}
+declare module "babylonjs-node-editor/sharedComponents/checkBoxLineComponent" {
+import * as React from "react";
+import { Observable } from "babylonjs/Misc/observable";
+import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
+export interface ICheckBoxLineComponentProps {
+    label: string;
+    target?: any;
+    propertyName?: string;
+    isSelected?: () => boolean;
+    onSelect?: (value: boolean) => void;
+    onValueChanged?: () => void;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+    disabled?: boolean;
+}
+export declare class CheckBoxLineComponent extends React.Component<ICheckBoxLineComponentProps, {
+    isSelected: boolean;
+    isDisabled?: boolean;
+}> {
+    private static _UniqueIdSeed;
+    private _uniqueId;
+    private _localChange;
+    constructor(props: ICheckBoxLineComponentProps);
+    shouldComponentUpdate(nextProps: ICheckBoxLineComponentProps, nextState: {
+        isSelected: boolean;
+        isDisabled: boolean;
+    }): boolean;
+    onChange(): void;
+    render(): JSX.Element;
+}
+
+}
+declare module "babylonjs-node-editor/sharedComponents/color3LineComponent" {
+import * as React from "react";
+import { Observable } from "babylonjs/Misc/observable";
+import { Color3, Color4 } from "babylonjs/Maths/math.color";
+import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+export interface IColor3LineComponentProps {
+    label: string;
+    target: any;
+    propertyName: string;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+    onChange?: () => void;
+    globalState: GlobalState;
+}
+export declare class Color3LineComponent extends React.Component<IColor3LineComponentProps, {
+    isExpanded: boolean;
+    color: Color3 | Color4;
+}> {
+    private _localChange;
+    constructor(props: IColor3LineComponentProps);
+    shouldComponentUpdate(nextProps: IColor3LineComponentProps, nextState: {
+        color: Color3 | Color4;
+    }): boolean;
+    onChange(newValue: string): void;
+    switchExpandState(): void;
+    raiseOnPropertyChanged(previousValue: Color3 | Color4): void;
+    updateStateR(value: number): void;
+    updateStateG(value: number): void;
+    updateStateB(value: number): void;
+    copyToClipboard(): void;
+    render(): JSX.Element;
+}
+
+}
+declare module "babylonjs-node-editor/sharedComponents/color4LineComponent" {
+import * as React from "react";
+import { Observable } from "babylonjs/Misc/observable";
+import { Color4 } from "babylonjs/Maths/math.color";
+import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+export interface IColor4LineComponentProps {
+    label: string;
+    target: any;
+    propertyName: string;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+    onChange?: () => void;
+    globalState: GlobalState;
+}
+export declare class Color4LineComponent extends React.Component<IColor4LineComponentProps, {
+    isExpanded: boolean;
+    color: Color4;
+}> {
+    private _localChange;
+    constructor(props: IColor4LineComponentProps);
+    shouldComponentUpdate(nextProps: IColor4LineComponentProps, nextState: {
+        color: Color4;
+    }): boolean;
+    onChange(newValue: string): void;
+    switchExpandState(): void;
+    raiseOnPropertyChanged(previousValue: Color4): void;
+    updateStateR(value: number): void;
+    updateStateG(value: number): void;
+    updateStateB(value: number): void;
+    updateStateA(value: number): void;
+    copyToClipboard(): void;
+    render(): JSX.Element;
+}
+
+}
+declare module "babylonjs-node-editor/sharedComponents/colorPickerComponent" {
+import * as React from "react";
+import { Color4, Color3 } from "babylonjs/Maths/math.color";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+export interface IColorPickerComponentProps {
+    value: Color4 | Color3;
+    onColorChanged: (newOne: string) => void;
+    globalState: GlobalState;
+}
+interface IColorPickerComponentState {
+    pickerEnabled: boolean;
+    color: Color3 | Color4;
+    hex: string;
+}
+export declare class ColorPickerLineComponent extends React.Component<IColorPickerComponentProps, IColorPickerComponentState> {
+    private _floatRef;
+    private _floatHostRef;
+    constructor(props: IColorPickerComponentProps);
+    syncPositions(): void;
+    shouldComponentUpdate(nextProps: IColorPickerComponentProps, nextState: IColorPickerComponentState): boolean;
+    componentDidUpdate(): void;
+    componentDidMount(): void;
+    setPickerState(enabled: boolean): void;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/sharedComponents/draggableLineComponent" {
+import * as React from "react";
+export interface IButtonLineComponentProps {
+    data: string;
+    tooltip: string;
+}
+export declare class DraggableLineComponent extends React.Component<IButtonLineComponentProps> {
+    constructor(props: IButtonLineComponentProps);
+    render(): JSX.Element;
+}
+
+}
+declare module "babylonjs-node-editor/sharedComponents/draggableLineWithButtonComponent" {
+import * as React from "react";
+export interface IDraggableLineWithButtonComponent {
+    data: string;
+    tooltip: string;
+    iconImage: any;
+    onIconClick: (value: string) => void;
+    iconTitle: string;
+    lenSuffixToRemove?: number;
+}
+export declare class DraggableLineWithButtonComponent extends React.Component<IDraggableLineWithButtonComponent> {
+    constructor(props: IDraggableLineWithButtonComponent);
+    render(): JSX.Element;
+}
+
+}
+declare module "babylonjs-node-editor/sharedComponents/fileButtonLineComponent" {
+import * as React from "react";
+interface IFileButtonLineComponentProps {
+    label: string;
+    onClick: (file: File) => void;
+    accept: string;
+    uploadName?: string;
+}
+export declare class FileButtonLineComponent extends React.Component<IFileButtonLineComponentProps> {
+    private uploadRef;
+    constructor(props: IFileButtonLineComponentProps);
+    onChange(evt: any): void;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/sharedComponents/floatLineComponent" {
+import * as React from "react";
+import { Observable } from "babylonjs/Misc/observable";
+import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+interface IFloatLineComponentProps {
+    label: string;
+    target: any;
+    propertyName: string;
+    onChange?: (newValue: number) => void;
+    isInteger?: boolean;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+    additionalClass?: string;
+    step?: string;
+    digits?: number;
+    globalState: GlobalState;
+    min?: number;
+    max?: number;
+    smallUI?: boolean;
+    onEnter?: (newValue: number) => void;
+}
+export declare class FloatLineComponent extends React.Component<IFloatLineComponentProps, {
+    value: string;
+}> {
+    private _localChange;
+    private _store;
+    private _regExp;
+    private _onFocus;
+    constructor(props: IFloatLineComponentProps);
+    shouldComponentUpdate(nextProps: IFloatLineComponentProps, nextState: {
+        value: string;
+    }): boolean;
+    componentWillUnmount(): void;
+    raiseOnPropertyChanged(newValue: number, previousValue: number): void;
+    updateValue(valueString: string): void;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/sharedComponents/lineContainerComponent" {
+import * as React from "react";
+interface ILineContainerComponentProps {
+    title: string;
+    children: any[] | any;
+    closed?: boolean;
+}
+export declare class LineContainerComponent extends React.Component<ILineContainerComponentProps, {
+    isExpanded: boolean;
+}> {
+    constructor(props: ILineContainerComponentProps);
+    switchExpandedState(): void;
+    renderHeader(): JSX.Element;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/sharedComponents/lineWithFileButtonComponent" {
+import * as React from "react";
+interface ILineWithFileButtonComponentProps {
+    title: string;
+    closed?: boolean;
+    label: string;
+    iconImage: any;
+    onIconClick: (file: File) => void;
+    accept: string;
+    uploadName?: string;
+}
+export declare class LineWithFileButtonComponent extends React.Component<ILineWithFileButtonComponentProps, {
+    isExpanded: boolean;
+}> {
+    private uploadRef;
+    constructor(props: ILineWithFileButtonComponentProps);
+    onChange(evt: any): void;
+    switchExpandedState(): void;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/sharedComponents/matrixLineComponent" {
+import * as React from "react";
+import { Vector3, Matrix, Vector4 } from "babylonjs/Maths/math.vector";
+import { Observable } from "babylonjs/Misc/observable";
+import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+interface IMatrixLineComponentProps {
+    label: string;
+    target: any;
+    propertyName: string;
+    step?: number;
+    onChange?: (newValue: Matrix) => void;
+    onModeChange?: (mode: number) => void;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+    mode?: number;
+    globalState: GlobalState;
+}
+export declare class MatrixLineComponent extends React.Component<IMatrixLineComponentProps, {
+    value: Matrix;
+    mode: number;
+    angle: number;
+}> {
+    private _localChange;
+    constructor(props: IMatrixLineComponentProps);
+    shouldComponentUpdate(nextProps: IMatrixLineComponentProps, nextState: {
+        value: Matrix;
+        mode: number;
+        angle: number;
+    }): boolean;
+    raiseOnPropertyChanged(previousValue: Vector3): void;
+    updateMatrix(): void;
+    updateRow(value: Vector4, row: number): void;
+    updateBasedOnMode(value: number): void;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/sharedComponents/messageDialog" {
+import * as React from "react";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+interface IMessageDialogComponentProps {
+    globalState: GlobalState;
+}
+export declare class MessageDialogComponent extends React.Component<IMessageDialogComponentProps, {
+    message: string;
+    isError: boolean;
+}> {
+    constructor(props: IMessageDialogComponentProps);
+    render(): JSX.Element | null;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/sharedComponents/numericInputComponent" {
+import * as React from "react";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+interface INumericInputComponentProps {
+    label: string;
+    value: number;
+    step?: number;
+    onChange: (value: number) => void;
+    globalState: GlobalState;
+}
+export declare class NumericInputComponent extends React.Component<INumericInputComponentProps, {
+    value: string;
+}> {
+    static defaultProps: {
+        step: number;
+    };
+    private _localChange;
+    constructor(props: INumericInputComponentProps);
+    shouldComponentUpdate(nextProps: INumericInputComponentProps, nextState: {
+        value: string;
+    }): boolean;
+    updateValue(evt: any): void;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/sharedComponents/optionsLineComponent" {
+import * as React from "react";
+import { Observable } from "babylonjs/Misc/observable";
+import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
+import { IInspectableOptions } from "babylonjs/Misc/iInspectable";
+interface IOptionsLineComponentProps {
+    label: string;
+    target: any;
+    className?: string;
+    propertyName?: string;
+    options: IInspectableOptions[];
+    noDirectUpdate?: boolean;
+    onSelect?: (value: number | string) => void;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+    valuesAreStrings?: boolean;
+    defaultIfNull?: number;
+    getSelection?: (target: any) => number;
+}
+export declare class OptionsLineComponent extends React.Component<IOptionsLineComponentProps, {
+    value: number | string;
+}> {
+    private _localChange;
+    private _getValue;
+    constructor(props: IOptionsLineComponentProps);
+    setValue(value: string | number): void;
+    shouldComponentUpdate(nextProps: IOptionsLineComponentProps, nextState: {
+        value: number;
+    }): boolean;
+    raiseOnPropertyChanged(newValue: number | string, previousValue: number | string): void;
+    updateValue(valueString: string): void;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/sharedComponents/popup" {
+export declare class Popup {
+    static CreatePopup(title: string, windowVariableName: string, width?: number, height?: number): HTMLDivElement | null;
+    static _CopyStyles(sourceDoc: HTMLDocument, targetDoc: HTMLDocument): void;
+}
+
+}
+declare module "babylonjs-node-editor/sharedComponents/propertyChangedEvent" {
+export declare class PropertyChangedEvent {
+    object: any;
+    property: string;
+    value: any;
+    initialValue: any;
+}
+
+}
+declare module "babylonjs-node-editor/sharedComponents/sliderLineComponent" {
+import * as React from "react";
+import { Observable } from "babylonjs/Misc/observable";
+import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+interface ISliderLineComponentProps {
+    label: string;
+    target?: any;
+    propertyName?: string;
+    minimum: number;
+    maximum: number;
+    step: number;
+    directValue?: number;
+    useEuler?: boolean;
+    onChange?: (value: number) => void;
+    onInput?: (value: number) => void;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+    decimalCount?: number;
+    globalState: GlobalState;
+}
+export declare class SliderLineComponent extends React.Component<ISliderLineComponentProps, {
+    value: number;
+}> {
+    private _localChange;
+    constructor(props: ISliderLineComponentProps);
+    shouldComponentUpdate(nextProps: ISliderLineComponentProps, nextState: {
+        value: number;
+    }): boolean;
+    onChange(newValueString: any): void;
+    onInput(newValueString: any): void;
+    prepareDataToRead(value: number): number;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/sharedComponents/textInputLineComponent" {
+import * as React from "react";
+import { Observable } from "babylonjs/Misc/observable";
+import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+interface ITextInputLineComponentProps {
+    label: string;
+    globalState: GlobalState;
+    target?: any;
+    propertyName?: string;
+    value?: string;
+    multilines?: boolean;
+    onChange?: (value: string) => void;
+    validator?: (value: string) => boolean;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+}
+export declare class TextInputLineComponent extends React.Component<ITextInputLineComponentProps, {
+    value: string;
+}> {
+    private _localChange;
+    private _onFocus;
+    constructor(props: ITextInputLineComponentProps);
+    shouldComponentUpdate(nextProps: ITextInputLineComponentProps, nextState: {
+        value: string;
+    }): boolean;
+    componentWillUnmount(): void;
+    raiseOnPropertyChanged(newValue: string, previousValue: string): void;
+    updateValue(value: string, raisePropertyChanged: boolean): void;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/sharedComponents/textLineComponent" {
+import * as React from "react";
+interface ITextLineComponentProps {
+    label: string;
+    value: string;
+    color?: string;
+    underline?: boolean;
+    onLink?: () => void;
+}
+export declare class TextLineComponent extends React.Component<ITextLineComponentProps> {
+    constructor(props: ITextLineComponentProps);
+    onLink(): void;
+    renderContent(): JSX.Element;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/sharedComponents/textureLineComponent" {
+import * as React from "react";
+import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
+interface ITextureLineComponentProps {
+    texture: BaseTexture;
+    width: number;
+    height: number;
+    globalState?: any;
+    hideChannelSelect?: boolean;
+}
+export interface ITextureLineComponentState {
+    displayRed: boolean;
+    displayGreen: boolean;
+    displayBlue: boolean;
+    displayAlpha: boolean;
+    face: number;
+}
+export declare class TextureLineComponent extends React.Component<ITextureLineComponentProps, ITextureLineComponentState> {
+    private canvasRef;
+    constructor(props: ITextureLineComponentProps);
+    shouldComponentUpdate(nextProps: ITextureLineComponentProps, nextState: {
+        displayRed: boolean;
+        displayGreen: boolean;
+        displayBlue: boolean;
+        displayAlpha: boolean;
+        face: number;
+    }): boolean;
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    updatePreview(): void;
+    static UpdatePreview(previewCanvas: HTMLCanvasElement, texture: BaseTexture, width: number, options: ITextureLineComponentState, onReady?: () => void, globalState?: any): Promise<void>;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/sharedComponents/vector2LineComponent" {
+import * as React from "react";
+import { Vector2 } from "babylonjs/Maths/math.vector";
+import { Observable } from "babylonjs/Misc/observable";
+import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+interface IVector2LineComponentProps {
+    label: string;
+    target: any;
+    propertyName: string;
+    step?: number;
+    onChange?: (newvalue: Vector2) => void;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+    globalState: GlobalState;
+}
+export declare class Vector2LineComponent extends React.Component<IVector2LineComponentProps, {
+    isExpanded: boolean;
+    value: Vector2;
+}> {
+    static defaultProps: {
+        step: number;
+    };
+    private _localChange;
+    constructor(props: IVector2LineComponentProps);
+    shouldComponentUpdate(nextProps: IVector2LineComponentProps, nextState: {
+        isExpanded: boolean;
+        value: Vector2;
+    }): boolean;
+    switchExpandState(): void;
+    raiseOnPropertyChanged(previousValue: Vector2): void;
+    updateStateX(value: number): void;
+    updateStateY(value: number): void;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/sharedComponents/vector3LineComponent" {
+import * as React from "react";
+import { Vector3 } from "babylonjs/Maths/math.vector";
+import { Observable } from "babylonjs/Misc/observable";
+import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+interface IVector3LineComponentProps {
+    label: string;
+    target: any;
+    propertyName: string;
+    step?: number;
+    onChange?: (newvalue: Vector3) => void;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+    globalState: GlobalState;
+}
+export declare class Vector3LineComponent extends React.Component<IVector3LineComponentProps, {
+    isExpanded: boolean;
+    value: Vector3;
+}> {
+    static defaultProps: {
+        step: number;
+    };
+    private _localChange;
+    constructor(props: IVector3LineComponentProps);
+    shouldComponentUpdate(nextProps: IVector3LineComponentProps, nextState: {
+        isExpanded: boolean;
+        value: Vector3;
+    }): boolean;
+    switchExpandState(): void;
+    raiseOnPropertyChanged(previousValue: Vector3): void;
+    updateVector3(): void;
+    updateStateX(value: number): void;
+    updateStateY(value: number): void;
+    updateStateZ(value: number): void;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/sharedComponents/vector4LineComponent" {
+import * as React from "react";
+import { Vector4 } from "babylonjs/Maths/math.vector";
+import { Observable } from "babylonjs/Misc/observable";
+import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
+import { GlobalState } from "babylonjs-node-editor/globalState";
+interface IVector4LineComponentProps {
+    label: string;
+    target?: any;
+    propertyName?: string;
+    value?: Vector4;
+    step?: number;
+    onChange?: (newvalue: Vector4) => void;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+    globalState: GlobalState;
+}
+export declare class Vector4LineComponent extends React.Component<IVector4LineComponentProps, {
+    isExpanded: boolean;
+    value: Vector4;
+}> {
+    static defaultProps: {
+        step: number;
+    };
+    private _localChange;
+    constructor(props: IVector4LineComponentProps);
+    shouldComponentUpdate(nextProps: IVector4LineComponentProps, nextState: {
+        isExpanded: boolean;
+        value: Vector4;
+    }): boolean;
+    switchExpandState(): void;
+    raiseOnPropertyChanged(previousValue: Vector4): void;
+    updateVector4(): void;
+    updateStateX(value: number): void;
+    updateStateY(value: number): void;
+    updateStateZ(value: number): void;
+    updateStateW(value: number): void;
+    render(): JSX.Element;
+}
+export {};
+
+}
+
+declare module "babylonjs-node-editor" {
+    export * from "babylonjs-node-editor/legacy/legacy";
+}
+
+declare module BABYLON.NodeEditor {
+        export class BlockTools {
        static GetBlockFromString(data: string, scene: BABYLON.Scene, nodeMaterial: BABYLON.NodeMaterial): BABYLON.ElbowBlock | BABYLON.TwirlBlock | BABYLON.VoronoiNoiseBlock | BABYLON.ScreenSpaceBlock | BABYLON.CloudBlock | BABYLON.MatrixBuilderBlock | BABYLON.DesaturateBlock | BABYLON.RefractBlock | BABYLON.ReflectBlock | BABYLON.DerivativeBlock | BABYLON.Rotate2dBlock | BABYLON.NormalBlendBlock | BABYLON.WorleyNoise3DBlock | BABYLON.SimplexPerlin3DBlock | BABYLON.BonesBlock | BABYLON.InstancesBlock | BABYLON.MorphTargetsBlock | BABYLON.DiscardBlock | BABYLON.ImageProcessingBlock | BABYLON.ColorMergerBlock | BABYLON.VectorMergerBlock | BABYLON.ColorSplitterBlock | BABYLON.VectorSplitterBlock | BABYLON.TextureBlock | BABYLON.ReflectionTextureBlock | BABYLON.LightBlock | BABYLON.FogBlock | BABYLON.VertexOutputBlock | BABYLON.FragmentOutputBlock | BABYLON.AddBlock | BABYLON.ClampBlock | BABYLON.ScaleBlock | BABYLON.CrossBlock | BABYLON.DotBlock | BABYLON.PowBlock | BABYLON.MultiplyBlock | BABYLON.TransformBlock | BABYLON.TrigonometryBlock | BABYLON.RemapBlock | BABYLON.NormalizeBlock | BABYLON.FresnelBlock | BABYLON.LerpBlock | BABYLON.NLerpBlock | BABYLON.DivideBlock | BABYLON.SubtractBlock | BABYLON.ModBlock | BABYLON.StepBlock | BABYLON.SmoothStepBlock | BABYLON.OneMinusBlock | BABYLON.ReciprocalBlock | BABYLON.ViewDirectionBlock | BABYLON.LightInformationBlock | BABYLON.MaxBlock | BABYLON.MinBlock | BABYLON.LengthBlock | BABYLON.DistanceBlock | BABYLON.NegateBlock | BABYLON.PerturbNormalBlock | BABYLON.RandomNumberBlock | BABYLON.ReplaceColorBlock | BABYLON.PosterizeBlock | BABYLON.ArcTan2Block | BABYLON.GradientBlock | BABYLON.FrontFacingBlock | BABYLON.WaveBlock | BABYLON.InputBlock | BABYLON.PBRMetallicRoughnessBlock | BABYLON.SheenBlock | BABYLON.AnisotropyBlock | BABYLON.ReflectionBlock | BABYLON.ClearCoatBlock | BABYLON.RefractionBlock | BABYLON.SubSurfaceBlock | BABYLON.CurrentScreenBlock | BABYLON.ParticleTextureBlock | BABYLON.ParticleRampGradientBlock | BABYLON.ParticleBlendMultiplyBlock | BABYLON.FragCoordBlock | BABYLON.ScreenSizeBlock | BABYLON.SceneDepthBlock | BABYLON.ConditionalBlock | BABYLON.ImageSourceBlock | BABYLON.ClipPlanesBlock | null;
        static GetColorFromConnectionNodeType(type: BABYLON.NodeMaterialBlockConnectionPointTypes): string;
        static GetConnectionNodeTypeFromString(type: string): BABYLON.NodeMaterialBlockConnectionPointTypes.Float | BABYLON.NodeMaterialBlockConnectionPointTypes.Vector2 | BABYLON.NodeMaterialBlockConnectionPointTypes.Vector3 | BABYLON.NodeMaterialBlockConnectionPointTypes.Vector4 | BABYLON.NodeMaterialBlockConnectionPointTypes.Color3 | BABYLON.NodeMaterialBlockConnectionPointTypes.Color4 | BABYLON.NodeMaterialBlockConnectionPointTypes.Matrix | BABYLON.NodeMaterialBlockConnectionPointTypes.AutoDetect;
        static GetStringFromConnectionNodeType(type: BABYLON.NodeMaterialBlockConnectionPointTypes): "" | "Float" | "Vector2" | "Vector3" | "Vector4" | "Matrix" | "Color3" | "Color4";
    }
+
+    interface ILogComponentProps {
        globalState: GlobalState;
    }
    export class LogEntry {
        message: string;
        isError: boolean;
        constructor(message: string, isError: boolean);
    }
    export class LogComponent extends React.Component<ILogComponentProps, {
        logs: LogEntry[];
    }> {
        constructor(props: ILogComponentProps);
        componentDidMount(): void;
        componentDidUpdate(): void;
        render(): JSX.Element;
    }
+
+    interface INodeListComponentProps {
        globalState: GlobalState;
    }
    export class NodeListComponent extends React.Component<INodeListComponentProps, {
        filter: string;
    }> {
        private _onResetRequiredObserver;
        private static _Tooltips;
        private _customFrameList;
        private _customBlockList;
        constructor(props: INodeListComponentProps);
        componentWillUnmount(): void;
        filterContent(filter: string): void;
        loadCustomFrame(file: File): void;
        removeItem(value: string): void;
        loadCustomBlock(file: File): void;
        removeCustomBlock(value: string): void;
        render(): JSX.Element;
    }
+
+    interface IPreviewAreaComponentProps {
        globalState: GlobalState;
        width: number;
    }
    export class PreviewAreaComponent extends React.Component<IPreviewAreaComponentProps, {
        isLoading: boolean;
    }> {
        private _onIsLoadingChangedObserver;
        private _onResetRequiredObserver;
        constructor(props: IPreviewAreaComponentProps);
        componentWillUnmount(): void;
        changeBackFaceCulling(value: boolean): void;
        changeDepthPrePass(value: boolean): void;
        changeParticleSystemBlendMode(newOne: number): void;
        render(): JSX.Element;
    }
+
+    export class PreviewManager {
        private _nodeMaterial;
        private _onBuildObserver;
        private _onPreviewCommandActivatedObserver;
        private _onAnimationCommandActivatedObserver;
        private _onUpdateRequiredObserver;
        private _onPreviewBackgroundChangedObserver;
        private _onBackFaceCullingChangedObserver;
        private _onDepthPrePassChangedObserver;
        private _onLightUpdatedObserver;
        private _engine;
        private _scene;
        private _meshes;
        private _camera;
        private _material;
        private _globalState;
        private _currentType;
        private _lightParent;
        private _postprocess;
        private _proceduralTexture;
        private _particleSystem;
        private _layer;
        constructor(targetCanvas: HTMLCanvasElement, globalState: GlobalState);
        private _handleAnimations;
        private _prepareLights;
        private _prepareScene;
        private _refreshPreviewMesh;
        private _loadParticleSystem;
        private _forceCompilationAsync;
        private _updatePreview;
        dispose(): void;
    }
+
+    interface IPreviewMeshControlComponent {
        globalState: GlobalState;
        togglePreviewAreaComponent: () => void;
    }
    export class PreviewMeshControlComponent extends React.Component<IPreviewMeshControlComponent> {
        private colorInputRef;
        private filePickerRef;
        private _onResetRequiredObserver;
        constructor(props: IPreviewMeshControlComponent);
        componentWillUnmount(): void;
        changeMeshType(newOne: PreviewType): void;
        useCustomMesh(evt: any): void;
        onPopUp(): void;
        changeAnimation(): void;
        changeBackground(value: string): void;
        changeBackgroundClick(): void;
        render(): JSX.Element;
    }
+
+    export enum PreviewType {
        Sphere = 0,
        Box = 1,
        Torus = 2,
        Cylinder = 3,
        Plane = 4,
        ShaderBall = 5,
        DefaultParticleSystem = 6,
        Bubbles = 7,
        Smoke = 8,
        Rain = 9,
        Explosion = 10,
        Fire = 11,
        Custom = 12
    }
+
+    interface IInputsPropertyTabComponentProps {
        globalState: GlobalState;
        inputs: BABYLON.InputBlock[];
    }
    export class InputsPropertyTabComponent extends React.Component<IInputsPropertyTabComponentProps> {
        constructor(props: IInputsPropertyTabComponentProps);
        processInputBlockUpdate(ib: BABYLON.InputBlock): void;
        renderInputBlock(block: BABYLON.InputBlock): JSX.Element | null;
        render(): JSX.Element;
    }
+
+    interface IColor3PropertyTabComponentProps {
        globalState: GlobalState;
        inputBlock: BABYLON.InputBlock;
    }
    export class Color3PropertyTabComponent extends React.Component<IColor3PropertyTabComponentProps> {
        render(): JSX.Element;
    }
+
+    interface IColor4PropertyTabComponentProps {
        globalState: GlobalState;
        inputBlock: BABYLON.InputBlock;
    }
    export class Color4PropertyTabComponent extends React.Component<IColor4PropertyTabComponentProps> {
        render(): JSX.Element;
    }
+
+    interface IFloatPropertyTabComponentProps {
        globalState: GlobalState;
        inputBlock: BABYLON.InputBlock;
    }
    export class FloatPropertyTabComponent extends React.Component<IFloatPropertyTabComponentProps> {
        render(): JSX.Element;
    }
+
+    interface IMatrixPropertyTabComponentProps {
        globalState: GlobalState;
        inputBlock: BABYLON.InputBlock;
    }
    export class MatrixPropertyTabComponent extends React.Component<IMatrixPropertyTabComponentProps> {
        render(): JSX.Element;
    }
+
+    interface IVector2PropertyTabComponentProps {
        globalState: GlobalState;
        inputBlock: BABYLON.InputBlock;
    }
    export class Vector2PropertyTabComponent extends React.Component<IVector2PropertyTabComponentProps> {
        render(): JSX.Element;
    }
+
+    interface IVector3PropertyTabComponentProps {
        globalState: GlobalState;
        inputBlock: BABYLON.InputBlock;
    }
    export class Vector3PropertyTabComponent extends React.Component<IVector3PropertyTabComponentProps> {
        render(): JSX.Element;
    }
+
+    interface IVector4PropertyTabComponentProps {
        globalState: GlobalState;
        inputBlock: BABYLON.InputBlock;
    }
    export class Vector4PropertyTabComponent extends React.Component<IVector4PropertyTabComponentProps> {
        render(): JSX.Element;
    }
+
+    interface IPropertyTabComponentProps {
        globalState: GlobalState;
    }
    interface IPropertyTabComponentState {
        currentNode: BABYLON.Nullable<GraphNode>;
        currentFrame: BABYLON.Nullable<GraphFrame>;
        currentFrameNodePort: BABYLON.Nullable<FrameNodePort>;
        currentNodePort: BABYLON.Nullable<NodePort>;
        uploadInProgress: boolean;
    }
    export class PropertyTabComponent extends React.Component<IPropertyTabComponentProps, IPropertyTabComponentState> {
        private _onBuiltObserver;
        private _modeSelect;
        constructor(props: IPropertyTabComponentProps);
        componentDidMount(): void;
        componentWillUnmount(): void;
        processInputBlockUpdate(ib: BABYLON.InputBlock): void;
        renderInputBlock(block: BABYLON.InputBlock): JSX.Element | null;
        load(file: File): void;
        loadFrame(file: File): void;
        save(): void;
        customSave(): void;
        saveToSnippetServer(): void;
        loadFromSnippet(): void;
        changeMode(value: any, force?: boolean, loadDefault?: boolean): boolean;
        render(): JSX.Element;
    }
+
+    export class ClampDisplayManager implements IDisplayManager {
        getHeaderClass(block: BABYLON.NodeMaterialBlock): string;
        shouldDisplayPortLabels(block: BABYLON.NodeMaterialBlock): boolean;
        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
    }
+
+    export class ConditionalDisplayManager implements IDisplayManager {
        getHeaderClass(block: BABYLON.NodeMaterialBlock): string;
        shouldDisplayPortLabels(block: BABYLON.NodeMaterialBlock): boolean;
        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
    }
+
+    export class DiscardDisplayManager implements IDisplayManager {
        getHeaderClass(block: BABYLON.NodeMaterialBlock): string;
        shouldDisplayPortLabels(block: BABYLON.NodeMaterialBlock): boolean;
        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
    }
+
+    export interface IDisplayManager {
        getHeaderClass(block: BABYLON.NodeMaterialBlock): string;
        shouldDisplayPortLabels(block: BABYLON.NodeMaterialBlock): boolean;
        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
    }
+
+    export class ElbowDisplayManager implements IDisplayManager {
        getHeaderClass(block: BABYLON.NodeMaterialBlock): string;
        shouldDisplayPortLabels(block: BABYLON.NodeMaterialBlock): boolean;
        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
    }
+
+    export class GradientDisplayManager implements IDisplayManager {
        getHeaderClass(block: BABYLON.NodeMaterialBlock): string;
        shouldDisplayPortLabels(block: BABYLON.NodeMaterialBlock): boolean;
        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
    }
+
+    export class imageSourceDisplayManager implements IDisplayManager {
        private _previewCanvas;
        private _previewImage;
        getHeaderClass(block: BABYLON.NodeMaterialBlock): string;
        shouldDisplayPortLabels(block: BABYLON.NodeMaterialBlock): boolean;
        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
    }
+
+    export class InputDisplayManager implements IDisplayManager {
        getHeaderClass(block: BABYLON.NodeMaterialBlock): "" | "constant" | "inspector";
        shouldDisplayPortLabels(block: BABYLON.NodeMaterialBlock): boolean;
        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
        static GetBaseType(type: BABYLON.NodeMaterialBlockConnectionPointTypes): string;
        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
    }
+
+    export class OutputDisplayManager implements IDisplayManager {
        getHeaderClass(block: BABYLON.NodeMaterialBlock): string;
        shouldDisplayPortLabels(block: BABYLON.NodeMaterialBlock): boolean;
        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
    }
+
+    export class PBRDisplayManager implements IDisplayManager {
        getHeaderClass(block: BABYLON.NodeMaterialBlock): string;
        shouldDisplayPortLabels(block: BABYLON.NodeMaterialBlock): boolean;
        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
    }
+
+    export class RemapDisplayManager implements IDisplayManager {
        getHeaderClass(block: BABYLON.NodeMaterialBlock): string;
        shouldDisplayPortLabels(block: BABYLON.NodeMaterialBlock): boolean;
        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
        private _extractInputValue;
        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
    }
+
+    export class TextureDisplayManager implements IDisplayManager {
        private _previewCanvas;
        private _previewImage;
        getHeaderClass(block: BABYLON.NodeMaterialBlock): string;
        shouldDisplayPortLabels(block: BABYLON.NodeMaterialBlock): boolean;
        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
    }
+
+    export class TrigonometryDisplayManager implements IDisplayManager {
        getHeaderClass(block: BABYLON.NodeMaterialBlock): string;
        shouldDisplayPortLabels(block: BABYLON.NodeMaterialBlock): boolean;
        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
    }
+
+    export class DisplayLedger {
        static RegisteredControls: {
            [key: string]: any;
        };
    }
+
+    export class FrameNodePort extends NodePort {
        connectionPoint: BABYLON.NodeMaterialConnectionPoint;
        node: GraphNode;
        private _parentFrameId;
        private _isInput;
        private _framePortPosition;
        private _framePortId;
        private _onFramePortPositionChangedObservable;
        get parentFrameId(): number;
        get onFramePortPositionChangedObservable(): BABYLON.Observable<FrameNodePort>;
        get isInput(): boolean;
        get framePortId(): number;
        get framePortPosition(): FramePortPosition;
        set framePortPosition(position: FramePortPosition);
        constructor(portContainer: HTMLElement, connectionPoint: BABYLON.NodeMaterialConnectionPoint, node: GraphNode, globalState: GlobalState, isInput: boolean, framePortId: number, parentFrameId: number);
        static CreateFrameNodePortElement(connectionPoint: BABYLON.NodeMaterialConnectionPoint, node: GraphNode, root: HTMLElement, displayManager: BABYLON.Nullable<IDisplayManager>, globalState: GlobalState, isInput: boolean, framePortId: number, parentFrameId: number): FrameNodePort;
    }
+
+    export interface IGraphCanvasComponentProps {
        globalState: GlobalState;
        onEmitNewBlock: (block: BABYLON.NodeMaterialBlock) => GraphNode;
    }
    export type FramePortData = {
        frame: GraphFrame;
        port: FrameNodePort;
    };
    export const isFramePortData: (variableToCheck: any) => variableToCheck is FramePortData;
    export class GraphCanvasComponent extends React.Component<IGraphCanvasComponentProps> {
        private readonly MinZoom;
        private readonly MaxZoom;
        private _hostCanvas;
        private _graphCanvas;
        private _selectionContainer;
        private _frameContainer;
        private _svgCanvas;
        private _rootContainer;
        private _nodes;
        private _links;
        private _mouseStartPointX;
        private _mouseStartPointY;
        private _dropPointX;
        private _dropPointY;
        private _selectionStartX;
        private _selectionStartY;
        private _candidateLinkedHasMoved;
        private _x;
        private _y;
        private _zoom;
        private _selectedNodes;
        private _selectedLink;
        private _selectedPort;
        private _candidateLink;
        private _candidatePort;
        private _gridSize;
        private _selectionBox;
        private _selectedFrame;
        private _frameCandidate;
        private _frames;
        private _altKeyIsPressed;
        private _ctrlKeyIsPressed;
        private _oldY;
        _frameIsMoving: boolean;
        _isLoading: boolean;
        get gridSize(): number;
        set gridSize(value: number);
        get globalState(): GlobalState;
        get nodes(): GraphNode[];
        get links(): NodeLink[];
        get frames(): GraphFrame[];
        get zoom(): number;
        set zoom(value: number);
        get x(): number;
        set x(value: number);
        get y(): number;
        set y(value: number);
        get selectedNodes(): GraphNode[];
        get selectedLink(): BABYLON.Nullable<NodeLink>;
        get selectedFrame(): BABYLON.Nullable<GraphFrame>;
        get selectedPort(): BABYLON.Nullable<NodePort>;
        get canvasContainer(): HTMLDivElement;
        get hostCanvas(): HTMLDivElement;
        get svgCanvas(): HTMLElement;
        get selectionContainer(): HTMLDivElement;
        get frameContainer(): HTMLDivElement;
        constructor(props: IGraphCanvasComponentProps);
        static _RefreshNode: (node: GraphNode, visitedNodes?: Set<GraphNode> | undefined, visitedLinks?: Set<NodeLink> | undefined) => void;
        getGridPosition(position: number, useCeil?: boolean): number;
        getGridPositionCeil(position: number): number;
        updateTransform(): void;
        onKeyUp(): void;
        findNodeFromBlock(block: BABYLON.NodeMaterialBlock): GraphNode;
        reset(): void;
        connectPorts(pointA: BABYLON.NodeMaterialConnectionPoint, pointB: BABYLON.NodeMaterialConnectionPoint): void;
        removeLink(link: NodeLink): void;
        appendBlock(block: BABYLON.NodeMaterialBlock): GraphNode;
        distributeGraph(): void;
        componentDidMount(): void;
        onMove(evt: React.PointerEvent): void;
        onDown(evt: React.PointerEvent<HTMLElement>): void;
        onUp(evt: React.PointerEvent): void;
        onWheel(evt: React.WheelEvent): void;
        zoomToFit(): void;
        processCandidatePort(): void;
        processEditorData(editorData: IEditorData): void;
        addFrame(frameData: IFrameData): void;
        render(): JSX.Element;
    }
+
+    export enum FramePortPosition {
        Top = 0,
        Middle = 1,
        Bottom = 2
    }
    export class GraphFrame {
        private readonly CollapsedWidth;
        private static _FrameCounter;
        private static _FramePortCounter;
        private _name;
        private _color;
        private _x;
        private _y;
        private _gridAlignedX;
        private _gridAlignedY;
        private _width;
        private _height;
        element: HTMLDivElement;
        private _borderElement;
        private _headerElement;
        private _headerTextElement;
        private _headerCollapseElement;
        private _headerCloseElement;
        private _commentsElement;
        private _portContainer;
        private _outputPortContainer;
        private _inputPortContainer;
        private _nodes;
        private _ownerCanvas;
        private _mouseStartPointX;
        private _mouseStartPointY;
        private _onSelectionChangedObserver;
        private _onGraphNodeRemovalObserver;
        private _onExposePortOnFrameObserver;
        private _onNodeLinkDisposedObservers;
        private _isCollapsed;
        private _frameInPorts;
        private _frameOutPorts;
        private _controlledPorts;
        private _exposedInPorts;
        private _exposedOutPorts;
        private _id;
        private _comments;
        private _frameIsResizing;
        private _resizingDirection;
        private _minFrameHeight;
        private _minFrameWidth;
        private mouseXLimit;
        onExpandStateChanged: BABYLON.Observable<GraphFrame>;
        private readonly CloseSVG;
        private readonly ExpandSVG;
        private readonly CollapseSVG;
        get id(): number;
        get isCollapsed(): boolean;
        private _createInputPort;
        private _markFramePortPositions;
        private _createFramePorts;
        private removePortFromExposedWithNode;
        private removePortFromExposedWithLink;
        private createInputPorts;
        private createOutputPorts;
        redrawFramePorts(): void;
        set isCollapsed(value: boolean);
        get nodes(): GraphNode[];
        get ports(): FrameNodePort[];
        get name(): string;
        set name(value: string);
        get color(): BABYLON.Color3;
        set color(value: BABYLON.Color3);
        get x(): number;
        set x(value: number);
        get y(): number;
        set y(value: number);
        get width(): number;
        set width(value: number);
        get height(): number;
        set height(value: number);
        get comments(): string;
        set comments(comments: string);
        constructor(candidate: BABYLON.Nullable<HTMLDivElement>, canvas: GraphCanvasComponent, doNotCaptureNodes?: boolean);
        refresh(): void;
        addNode(node: GraphNode): void;
        removeNode(node: GraphNode): void;
        syncNode(node: GraphNode): void;
        cleanAccumulation(): void;
        private _onDown;
        move(newX: number, newY: number, align?: boolean): void;
        private _onUp;
        private _moveFrame;
        private _onMove;
        moveFramePortUp(nodePort: FrameNodePort): void;
        private _movePortUp;
        moveFramePortDown(nodePort: FrameNodePort): void;
        private _movePortDown;
        private initResizing;
        private cleanUpResizing;
        private updateMinHeightWithComments;
        private _isResizingTop;
        private _isResizingRight;
        private _isResizingBottom;
        private _isResizingLeft;
        private _onRightHandlePointerDown;
        private _onRightHandlePointerMove;
        private _moveRightHandle;
        private _onRightHandlePointerUp;
        private _onBottomHandlePointerDown;
        private _onBottomHandlePointerMove;
        private _moveBottomHandle;
        private _onBottomHandlePointerUp;
        private _onLeftHandlePointerDown;
        private _onLeftHandlePointerMove;
        private _moveLeftHandle;
        private _onLeftHandlePointerUp;
        private _onTopHandlePointerDown;
        private _onTopHandlePointerMove;
        private _moveTopHandle;
        private _onTopHandlePointerUp;
        private _onTopRightHandlePointerDown;
        private _onTopRightHandlePointerMove;
        private _moveTopRightHandle;
        private _onTopRightHandlePointerUp;
        private _onBottomRightHandlePointerDown;
        private _onBottomRightHandlePointerMove;
        private _moveBottomRightHandle;
        private _onBottomRightHandlePointerUp;
        private _onBottomLeftHandlePointerDown;
        private _onBottomLeftHandlePointerMove;
        private _moveBottomLeftHandle;
        private _onBottomLeftHandlePointerUp;
        private _onTopLeftHandlePointerDown;
        private _onTopLeftHandlePointerMove;
        private _moveTopLeftHandle;
        private _onTopLeftHandlePointerUp;
        private _expandLeft;
        private _expandTop;
        private _expandRight;
        private _expandBottom;
        dispose(): void;
        private serializePortData;
        serialize(saveCollapsedState: boolean): IFrameData;
        export(): void;
        adjustPorts(): void;
        static Parse(serializationData: IFrameData, canvas: GraphCanvasComponent, map?: {
            [key: number]: number;
        }): GraphFrame;
    }
+
+    /// <reference types="react" />
    export class GraphNode {
        block: BABYLON.NodeMaterialBlock;
        private _visual;
        private _headerContainer;
        private _promotionWarning;
        private _header;
        private _connections;
        private _inputsContainer;
        private _outputsContainer;
        private _content;
        private _comments;
        private _inputPorts;
        private _outputPorts;
        private _links;
        private _x;
        private _y;
        private _gridAlignedX;
        private _gridAlignedY;
        private _mouseStartPointX;
        private _mouseStartPointY;
        private _globalState;
        private _onSelectionChangedObserver;
        private _onSelectionBoxMovedObserver;
        private _onFrameCreatedObserver;
        private _onUpdateRequiredObserver;
        private _ownerCanvas;
        private _isSelected;
        private _displayManager;
        private _isVisible;
        private _enclosingFrameId;
        get isVisible(): boolean;
        set isVisible(value: boolean);
        private _upateNodePortNames;
        get outputPorts(): NodePort[];
        get inputPorts(): NodePort[];
        get links(): NodeLink[];
        get gridAlignedX(): number;
        get gridAlignedY(): number;
        get x(): number;
        set x(value: number);
        get y(): number;
        set y(value: number);
        get width(): number;
        get height(): number;
        get id(): number;
        get name(): string;
        get isSelected(): boolean;
        get enclosingFrameId(): number;
        set enclosingFrameId(value: number);
        set isSelected(value: boolean);
        constructor(block: BABYLON.NodeMaterialBlock, globalState: GlobalState);
        isOverlappingFrame(frame: GraphFrame): boolean;
        getPortForConnectionPoint(point: BABYLON.NodeMaterialConnectionPoint): NodePort | null;
        getLinksForConnectionPoint(point: BABYLON.NodeMaterialConnectionPoint): NodeLink[];
        private _refreshFrames;
        _refreshLinks(): void;
        refresh(): void;
        private _onDown;
        cleanAccumulation(useCeil?: boolean): void;
        private _onUp;
        private _onMove;
        renderProperties(): BABYLON.Nullable<JSX.Element>;
        appendVisual(root: HTMLDivElement, owner: GraphCanvasComponent): void;
        dispose(): void;
    }
+
+    export class NodeLink {
        private _graphCanvas;
        private _portA;
        private _portB?;
        private _nodeA;
        private _nodeB?;
        private _path;
        private _selectionPath;
        private _onSelectionChangedObserver;
        private _isVisible;
        onDisposedObservable: BABYLON.Observable<NodeLink>;
        get isVisible(): boolean;
        set isVisible(value: boolean);
        get portA(): NodePort | FrameNodePort;
        get portB(): NodePort | FrameNodePort | undefined;
        get nodeA(): GraphNode;
        get nodeB(): GraphNode | undefined;
        update(endX?: number, endY?: number, straight?: boolean): void;
        constructor(graphCanvas: GraphCanvasComponent, portA: NodePort, nodeA: GraphNode, portB?: NodePort, nodeB?: GraphNode);
        onClick(): void;
        dispose(notify?: boolean): void;
    }
+
+    export class NodePort {
        connectionPoint: BABYLON.NodeMaterialConnectionPoint;
        node: GraphNode;
        protected _element: HTMLDivElement;
        protected _img: HTMLImageElement;
        protected _globalState: GlobalState;
        protected _portLabelElement: Element;
        protected _onCandidateLinkMovedObserver: BABYLON.Nullable<BABYLON.Observer<BABYLON.Nullable<BABYLON.Vector2>>>;
        protected _onSelectionChangedObserver: BABYLON.Nullable<BABYLON.Observer<BABYLON.Nullable<GraphFrame | GraphNode | NodeLink | NodePort | FramePortData>>>;
        protected _exposedOnFrame: boolean;
        delegatedPort: BABYLON.Nullable<FrameNodePort>;
        get element(): HTMLDivElement;
        get portName(): string;
        set portName(newName: string);
        get disabled(): boolean;
        hasLabel(): boolean;
        get exposedOnFrame(): boolean;
        set exposedOnFrame(value: boolean);
        get exposedPortPosition(): number;
        set exposedPortPosition(value: number);
        private _isConnectedToNodeOutsideOfFrame;
        refresh(): void;
        constructor(portContainer: HTMLElement, connectionPoint: BABYLON.NodeMaterialConnectionPoint, node: GraphNode, globalState: GlobalState);
        dispose(): void;
        static CreatePortElement(connectionPoint: BABYLON.NodeMaterialConnectionPoint, node: GraphNode, root: HTMLElement, displayManager: BABYLON.Nullable<IDisplayManager>, globalState: GlobalState): NodePort;
    }
+
+    export class ColorMergerPropertyTabComponent extends React.Component<IPropertyComponentProps> {
        constructor(props: IPropertyComponentProps);
        render(): JSX.Element;
    }
+
+    export class ConditionalPropertyTabComponent extends React.Component<IPropertyComponentProps> {
        constructor(props: IPropertyComponentProps);
        render(): JSX.Element;
    }
+
+    export interface IFrameNodePortPropertyTabComponentProps {
        globalState: GlobalState;
        frameNodePort: FrameNodePort;
        frame: GraphFrame;
    }
    export class FrameNodePortPropertyTabComponent extends React.Component<IFrameNodePortPropertyTabComponentProps, {
        port: FrameNodePort;
    }> {
        private _onFramePortPositionChangedObserver;
        private _onSelectionChangedObserver;
        constructor(props: IFrameNodePortPropertyTabComponentProps);
        componentWillUnmount(): void;
        render(): JSX.Element;
    }
+
+    export interface IFramePropertyTabComponentProps {
        globalState: GlobalState;
        frame: GraphFrame;
    }
    export class FramePropertyTabComponent extends React.Component<IFramePropertyTabComponentProps> {
        private onFrameExpandStateChangedObserver;
        constructor(props: IFramePropertyTabComponentProps);
        componentDidMount(): void;
        componentWillUnmount(): void;
        render(): JSX.Element;
    }
+
+    export class GenericPropertyComponent extends React.Component<IPropertyComponentProps> {
        constructor(props: IPropertyComponentProps);
        render(): JSX.Element;
    }
    export class GeneralPropertyTabComponent extends React.Component<IPropertyComponentProps> {
        constructor(props: IPropertyComponentProps);
        render(): JSX.Element;
    }
    export class GenericPropertyTabComponent extends React.Component<IPropertyComponentProps> {
        constructor(props: IPropertyComponentProps);
        forceRebuild(notifiers?: {
            rebuild?: boolean;
            update?: boolean;
            activatePreviewCommand?: boolean;
            callback?: (scene: BABYLON.Scene) => void;
        }): void;
        render(): JSX.Element;
    }
+
+    export class GradientPropertyTabComponent extends React.Component<IPropertyComponentProps> {
        private onValueChangedObserver;
        constructor(props: IPropertyComponentProps);
        componentDidMount(): void;
        componentWillUnmount(): void;
        forceRebuild(): void;
        deleteStep(step: BABYLON.GradientBlockColorStep): void;
        copyStep(step: BABYLON.GradientBlockColorStep): void;
        addNewStep(): void;
        checkForReOrder(): void;
        render(): JSX.Element;
    }
+
+    interface IGradientStepComponentProps {
        globalState: GlobalState;
        step: BABYLON.GradientBlockColorStep;
        lineIndex: number;
        onDelete: () => void;
        onUpdateStep: () => void;
        onCheckForReOrder: () => void;
        onCopy?: () => void;
    }
    export class GradientStepComponent extends React.Component<IGradientStepComponentProps, {
        gradient: number;
    }> {
        constructor(props: IGradientStepComponentProps);
        updateColor(color: string): void;
        updateStep(gradient: number): void;
        onPointerUp(): void;
        render(): JSX.Element;
    }
+
+    export class ImageSourcePropertyTabComponent extends React.Component<IPropertyComponentProps, {
        isEmbedded: boolean;
    }> {
        get imageSourceBlock(): BABYLON.ImageSourceBlock;
        constructor(props: IPropertyComponentProps);
        UNSAFE_componentWillUpdate(nextProps: IPropertyComponentProps, nextState: {
            isEmbedded: boolean;
            loadAsCubeTexture: boolean;
        }): void;
        private _generateRandomForCache;
        updateAfterTextureLoad(): void;
        removeTexture(): void;
        _prepareTexture(): void;
        /**
         * Replaces the texture of the node
         * @param file the file of the texture to use
         */
        replaceTexture(file: File): void;
        replaceTextureWithUrl(url: string): void;
        render(): JSX.Element;
    }
+
+    export class InputPropertyTabComponent extends React.Component<IPropertyComponentProps> {
        private onValueChangedObserver;
        constructor(props: IPropertyComponentProps);
        componentDidMount(): void;
        componentWillUnmount(): void;
        renderValue(globalState: GlobalState): JSX.Element | null;
        setDefaultValue(): void;
        render(): JSX.Element;
    }
+
+    export class LightInformationPropertyTabComponent extends React.Component<IPropertyComponentProps> {
        render(): JSX.Element;
    }
+
+    export class LightPropertyTabComponent extends React.Component<IPropertyComponentProps> {
        render(): JSX.Element;
    }
+
+    export interface IFrameNodePortPropertyTabComponentProps {
        globalState: GlobalState;
        nodePort: NodePort;
    }
    export class NodePortPropertyTabComponent extends React.Component<IFrameNodePortPropertyTabComponentProps> {
        private _onSelectionChangedObserver;
        constructor(props: IFrameNodePortPropertyTabComponentProps);
        componentWillUnmount(): void;
        toggleExposeOnFrame(value: boolean): void;
        render(): JSX.Element;
    }
+
+    export interface IPropertyComponentProps {
        globalState: GlobalState;
        block: BABYLON.NodeMaterialBlock;
    }
+
+    type ReflectionTexture = BABYLON.ReflectionTextureBlock | BABYLON.ReflectionBlock | BABYLON.RefractionBlock;
    type AnyTexture = BABYLON.TextureBlock | ReflectionTexture | BABYLON.CurrentScreenBlock | BABYLON.ParticleTextureBlock;
    export class TexturePropertyTabComponent extends React.Component<IPropertyComponentProps, {
        isEmbedded: boolean;
        loadAsCubeTexture: boolean;
        textureIsPrefiltered: boolean;
    }> {
        get textureBlock(): AnyTexture;
        constructor(props: IPropertyComponentProps);
        UNSAFE_componentWillUpdate(nextProps: IPropertyComponentProps, nextState: {
            isEmbedded: boolean;
            loadAsCubeTexture: boolean;
        }): void;
        private _generateRandomForCache;
        updateAfterTextureLoad(): void;
        removeTexture(): void;
        _prepareTexture(): void;
        /**
         * Replaces the texture of the node
         * @param file the file of the texture to use
         */
        replaceTexture(file: File): void;
        replaceTextureWithUrl(url: string): void;
        render(): JSX.Element;
    }
+
+    export class TransformPropertyTabComponent extends React.Component<IPropertyComponentProps> {
        constructor(props: IPropertyComponentProps);
        render(): JSX.Element;
    }
+
+    export class TrigonometryPropertyTabComponent extends React.Component<IPropertyComponentProps> {
        constructor(props: IPropertyComponentProps);
        render(): JSX.Element;
    }
+
+    export class VectorMergerPropertyTabComponent extends React.Component<IPropertyComponentProps> {
        constructor(props: IPropertyComponentProps);
        render(): JSX.Element;
    }
+
+    export class PropertyLedger {
        static RegisteredControls: {
            [key: string]: ComponentClass<IPropertyComponentProps>;
        };
    }
+
+    export class GlobalState {
        nodeMaterial: BABYLON.NodeMaterial;
        hostElement: HTMLElement;
        hostDocument: HTMLDocument;
        hostWindow: Window;
        onSelectionChangedObservable: BABYLON.Observable<BABYLON.Nullable<GraphFrame | GraphNode | NodePort | NodeLink | FramePortData>>;
        onRebuildRequiredObservable: BABYLON.Observable<boolean>;
        onBuiltObservable: BABYLON.Observable<void>;
        onResetRequiredObservable: BABYLON.Observable<void>;
        onUpdateRequiredObservable: BABYLON.Observable<BABYLON.Nullable<BABYLON.NodeMaterialBlock>>;
        onZoomToFitRequiredObservable: BABYLON.Observable<void>;
        onReOrganizedRequiredObservable: BABYLON.Observable<void>;
        onLogRequiredObservable: BABYLON.Observable<LogEntry>;
        onErrorMessageDialogRequiredObservable: BABYLON.Observable<string>;
        onIsLoadingChanged: BABYLON.Observable<boolean>;
        onPreviewCommandActivated: BABYLON.Observable<boolean>;
        onLightUpdated: BABYLON.Observable<void>;
        onPreviewBackgroundChanged: BABYLON.Observable<void>;
        onBackFaceCullingChanged: BABYLON.Observable<void>;
        onDepthPrePassChanged: BABYLON.Observable<void>;
        onAnimationCommandActivated: BABYLON.Observable<void>;
        onCandidateLinkMoved: BABYLON.Observable<BABYLON.Nullable<BABYLON.Vector2>>;
        onSelectionBoxMoved: BABYLON.Observable<ClientRect | DOMRect>;
        onFrameCreatedObservable: BABYLON.Observable<GraphFrame>;
        onCandidatePortSelectedObservable: BABYLON.Observable<BABYLON.Nullable<NodePort | FrameNodePort>>;
        onImportFrameObservable: BABYLON.Observable<any>;
        onGraphNodeRemovalObservable: BABYLON.Observable<GraphNode>;
        onPopupClosedObservable: BABYLON.Observable<void>;
        onGetNodeFromBlock: (block: BABYLON.NodeMaterialBlock) => GraphNode;
        onGridSizeChanged: BABYLON.Observable<void>;
        onExposePortOnFrameObservable: BABYLON.Observable<GraphNode>;
        previewType: PreviewType;
        previewFile: File;
        particleSystemBlendMode: number;
        listOfCustomPreviewFiles: File[];
        rotatePreview: boolean;
        backgroundColor: BABYLON.Color4;
        backFaceCulling: boolean;
        depthPrePass: boolean;
        blockKeyboardEvents: boolean;
        hemisphericLight: boolean;
        directionalLight0: boolean;
        directionalLight1: boolean;
        controlCamera: boolean;
        storeEditorData: (serializationObject: any, frame?: BABYLON.Nullable<GraphFrame>) => void;
        _mode: BABYLON.NodeMaterialModes;
        /** Gets the mode */
        get mode(): BABYLON.NodeMaterialModes;
        /** Sets the mode */
        set mode(m: BABYLON.NodeMaterialModes);
        customSave?: {
            label: string;
            action: (data: string) => Promise<void>;
        };
        constructor();
    }
+
+    interface IGraphEditorProps {
        globalState: GlobalState;
    }
    interface IGraphEditorState {
        showPreviewPopUp: boolean;
    }
    interface IInternalPreviewAreaOptions extends BABYLON.IInspectorOptions {
        popup: boolean;
        original: boolean;
        explorerWidth?: string;
        inspectorWidth?: string;
        embedHostWidth?: string;
    }
    export class GraphEditor extends React.Component<IGraphEditorProps, IGraphEditorState> {
        private readonly NodeWidth;
        private _graphCanvas;
        private _startX;
        private _moveInProgress;
        private _leftWidth;
        private _rightWidth;
        private _blocks;
        private _previewManager;
        private _copiedNodes;
        private _copiedFrame;
        private _mouseLocationX;
        private _mouseLocationY;
        private _onWidgetKeyUpPointer;
        private _previewHost;
        private _popUpWindow;
        /**
         * Creates a node and recursivly creates its parent nodes from it's input
         * @param nodeMaterialBlock
         */
        createNodeFromObject(block: BABYLON.NodeMaterialBlock, recursion?: boolean): GraphNode;
        addValueNode(type: string): GraphNode;
        componentDidMount(): void;
        componentWillUnmount(): void;
        constructor(props: IGraphEditorProps);
        reconnectNewNodes(nodeIndex: number, newNodes: GraphNode[], sourceNodes: GraphNode[], done: boolean[]): void;
        pasteSelection(copiedNodes: GraphNode[], currentX: number, currentY: number, selectNew?: boolean): GraphNode[] | undefined;
        zoomToFit(): void;
        buildMaterial(autoConfigure?: boolean): void;
        build(): void;
        loadGraph(): void;
        showWaitScreen(): void;
        hideWaitScreen(): void;
        reOrganize(editorData?: BABYLON.Nullable<IEditorData>, isImportingAFrame?: boolean): void;
        onPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
        onPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
        resizeColumns(evt: React.PointerEvent<HTMLDivElement>, forLeft?: boolean): void;
        buildColumnLayout(): string;
        emitNewBlock(event: React.DragEvent<HTMLDivElement>): void;
        handlePopUp: () => void;
        handleClosingPopUp: () => void;
        initiatePreviewArea: (canvas?: HTMLCanvasElement) => void;
        createPopUp: () => void;
        createPopupWindow: (title: string, windowVariableName: string, width?: number, height?: number) => Window | null;
        createPreviewMeshControlHost: (options: IInternalPreviewAreaOptions, parentControl: BABYLON.Nullable<HTMLElement>) => void;
        createPreviewHost: (options: IInternalPreviewAreaOptions, parentControl: BABYLON.Nullable<HTMLElement>) => void;
        fixPopUpStyles: (document: Document) => void;
        render(): JSX.Element;
    }
+
+
+
+    /**
     * Interface used to specify creation options for the node editor
     */
    export interface INodeEditorOptions {
        nodeMaterial: BABYLON.NodeMaterial;
        hostElement?: HTMLElement;
        customSave?: {
            label: string;
            action: (data: string) => Promise<void>;
        };
        customLoadObservable?: BABYLON.Observable<any>;
    }
    /**
     * Class used to create a node editor
     */
    export class NodeEditor {
        private static _CurrentState;
        /**
         * Show the node editor
         * @param options defines the options to use to configure the node editor
         */
        static Show(options: INodeEditorOptions): void;
    }
+
+    export interface INodeLocationInfo {
        blockId: number;
        x: number;
        y: number;
    }
    export interface IFrameData {
        x: number;
        y: number;
        width: number;
        height: number;
        color: number[];
        name: string;
        isCollapsed: boolean;
        blocks: number[];
        comments: string;
    }
    export interface IEditorData {
        locations: INodeLocationInfo[];
        x: number;
        y: number;
        zoom: number;
        frames?: IFrameData[];
        map?: {
            [key: number]: number;
        };
    }
+
+    interface IPortalProps {
        globalState: GlobalState;
    }
    export class Portal extends React.Component<IPortalProps> {
        render(): React.ReactPortal;
    }
+
+    export class SerializationTools {
        static UpdateLocations(material: BABYLON.NodeMaterial, globalState: GlobalState, frame?: BABYLON.Nullable<GraphFrame>): void;
        static Serialize(material: BABYLON.NodeMaterial, globalState: GlobalState, frame?: BABYLON.Nullable<GraphFrame>): string;
        static Deserialize(serializationObject: any, globalState: GlobalState): void;
        static AddFrameToMaterial(serializationObject: any, globalState: GlobalState, currentMaterial: BABYLON.NodeMaterial): void;
    }
+
+    export interface IButtonLineComponentProps {
        label: string;
        onClick: () => void;
        isDisabled?: boolean;
    }
    export class ButtonLineComponent extends React.Component<IButtonLineComponentProps> {
        constructor(props: IButtonLineComponentProps);
        render(): JSX.Element;
    }
+
+    export interface ICheckBoxLineComponentProps {
        label: string;
        target?: any;
        propertyName?: string;
        isSelected?: () => boolean;
        onSelect?: (value: boolean) => void;
        onValueChanged?: () => void;
        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
        disabled?: boolean;
    }
    export class CheckBoxLineComponent extends React.Component<ICheckBoxLineComponentProps, {
        isSelected: boolean;
        isDisabled?: boolean;
    }> {
        private static _UniqueIdSeed;
        private _uniqueId;
        private _localChange;
        constructor(props: ICheckBoxLineComponentProps);
        shouldComponentUpdate(nextProps: ICheckBoxLineComponentProps, nextState: {
            isSelected: boolean;
            isDisabled: boolean;
        }): boolean;
        onChange(): void;
        render(): JSX.Element;
    }
+
+    export interface IColor3LineComponentProps {
        label: string;
        target: any;
        propertyName: string;
        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
        onChange?: () => void;
        globalState: GlobalState;
    }
    export class Color3LineComponent extends React.Component<IColor3LineComponentProps, {
        isExpanded: boolean;
        color: BABYLON.Color3 | BABYLON.Color4;
    }> {
        private _localChange;
        constructor(props: IColor3LineComponentProps);
        shouldComponentUpdate(nextProps: IColor3LineComponentProps, nextState: {
            color: BABYLON.Color3 | BABYLON.Color4;
        }): boolean;
        onChange(newValue: string): void;
        switchExpandState(): void;
        raiseOnPropertyChanged(previousValue: BABYLON.Color3 | BABYLON.Color4): void;
        updateStateR(value: number): void;
        updateStateG(value: number): void;
        updateStateB(value: number): void;
        copyToClipboard(): void;
        render(): JSX.Element;
    }
+
+    export interface IColor4LineComponentProps {
        label: string;
        target: any;
        propertyName: string;
        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
        onChange?: () => void;
        globalState: GlobalState;
    }
    export class Color4LineComponent extends React.Component<IColor4LineComponentProps, {
        isExpanded: boolean;
        color: BABYLON.Color4;
    }> {
        private _localChange;
        constructor(props: IColor4LineComponentProps);
        shouldComponentUpdate(nextProps: IColor4LineComponentProps, nextState: {
            color: BABYLON.Color4;
        }): boolean;
        onChange(newValue: string): void;
        switchExpandState(): void;
        raiseOnPropertyChanged(previousValue: BABYLON.Color4): void;
        updateStateR(value: number): void;
        updateStateG(value: number): void;
        updateStateB(value: number): void;
        updateStateA(value: number): void;
        copyToClipboard(): void;
        render(): JSX.Element;
    }
+
+    export interface IColorPickerComponentProps {
        value: BABYLON.Color4 | BABYLON.Color3;
        onColorChanged: (newOne: string) => void;
        globalState: GlobalState;
    }
    interface IColorPickerComponentState {
        pickerEnabled: boolean;
        color: BABYLON.Color3 | BABYLON.Color4;
        hex: string;
    }
    export class ColorPickerLineComponent extends React.Component<IColorPickerComponentProps, IColorPickerComponentState> {
        private _floatRef;
        private _floatHostRef;
        constructor(props: IColorPickerComponentProps);
        syncPositions(): void;
        shouldComponentUpdate(nextProps: IColorPickerComponentProps, nextState: IColorPickerComponentState): boolean;
        componentDidUpdate(): void;
        componentDidMount(): void;
        setPickerState(enabled: boolean): void;
        render(): JSX.Element;
    }
+
+    export interface IButtonLineComponentProps {
        data: string;
        tooltip: string;
    }
    export class DraggableLineComponent extends React.Component<IButtonLineComponentProps> {
        constructor(props: IButtonLineComponentProps);
        render(): JSX.Element;
    }
+
+    export interface IDraggableLineWithButtonComponent {
        data: string;
        tooltip: string;
        iconImage: any;
        onIconClick: (value: string) => void;
        iconTitle: string;
        lenSuffixToRemove?: number;
    }
    export class DraggableLineWithButtonComponent extends React.Component<IDraggableLineWithButtonComponent> {
        constructor(props: IDraggableLineWithButtonComponent);
        render(): JSX.Element;
    }
+
+    interface IFileButtonLineComponentProps {
        label: string;
        onClick: (file: File) => void;
        accept: string;
        uploadName?: string;
    }
    export class FileButtonLineComponent extends React.Component<IFileButtonLineComponentProps> {
        private uploadRef;
        constructor(props: IFileButtonLineComponentProps);
        onChange(evt: any): void;
        render(): JSX.Element;
    }
+
+    interface IFloatLineComponentProps {
        label: string;
        target: any;
        propertyName: string;
        onChange?: (newValue: number) => void;
        isInteger?: boolean;
        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
        additionalClass?: string;
        step?: string;
        digits?: number;
        globalState: GlobalState;
        min?: number;
        max?: number;
        smallUI?: boolean;
        onEnter?: (newValue: number) => void;
    }
    export class FloatLineComponent extends React.Component<IFloatLineComponentProps, {
        value: string;
    }> {
        private _localChange;
        private _store;
        private _regExp;
        private _onFocus;
        constructor(props: IFloatLineComponentProps);
        shouldComponentUpdate(nextProps: IFloatLineComponentProps, nextState: {
            value: string;
        }): boolean;
        componentWillUnmount(): void;
        raiseOnPropertyChanged(newValue: number, previousValue: number): void;
        updateValue(valueString: string): void;
        render(): JSX.Element;
    }
+
+    interface ILineContainerComponentProps {
        title: string;
        children: any[] | any;
        closed?: boolean;
    }
    export class LineContainerComponent extends React.Component<ILineContainerComponentProps, {
        isExpanded: boolean;
    }> {
        constructor(props: ILineContainerComponentProps);
        switchExpandedState(): void;
        renderHeader(): JSX.Element;
        render(): JSX.Element;
    }
+
+    interface ILineWithFileButtonComponentProps {
        title: string;
        closed?: boolean;
        label: string;
        iconImage: any;
        onIconClick: (file: File) => void;
        accept: string;
        uploadName?: string;
    }
    export class LineWithFileButtonComponent extends React.Component<ILineWithFileButtonComponentProps, {
        isExpanded: boolean;
    }> {
        private uploadRef;
        constructor(props: ILineWithFileButtonComponentProps);
        onChange(evt: any): void;
        switchExpandedState(): void;
        render(): JSX.Element;
    }
+
+    interface IMatrixLineComponentProps {
        label: string;
        target: any;
        propertyName: string;
        step?: number;
        onChange?: (newValue: BABYLON.Matrix) => void;
        onModeChange?: (mode: number) => void;
        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
        mode?: number;
        globalState: GlobalState;
    }
    export class MatrixLineComponent extends React.Component<IMatrixLineComponentProps, {
        value: BABYLON.Matrix;
        mode: number;
        angle: number;
    }> {
        private _localChange;
        constructor(props: IMatrixLineComponentProps);
        shouldComponentUpdate(nextProps: IMatrixLineComponentProps, nextState: {
            value: BABYLON.Matrix;
            mode: number;
            angle: number;
        }): boolean;
        raiseOnPropertyChanged(previousValue: BABYLON.Vector3): void;
        updateMatrix(): void;
        updateRow(value: BABYLON.Vector4, row: number): void;
        updateBasedOnMode(value: number): void;
        render(): JSX.Element;
    }
+
+    interface IMessageDialogComponentProps {
        globalState: GlobalState;
    }
    export class MessageDialogComponent extends React.Component<IMessageDialogComponentProps, {
        message: string;
        isError: boolean;
    }> {
        constructor(props: IMessageDialogComponentProps);
        render(): JSX.Element | null;
    }
+
+    interface INumericInputComponentProps {
        label: string;
        value: number;
        step?: number;
        onChange: (value: number) => void;
        globalState: GlobalState;
    }
    export class NumericInputComponent extends React.Component<INumericInputComponentProps, {
        value: string;
    }> {
        static defaultProps: {
            step: number;
        };
        private _localChange;
        constructor(props: INumericInputComponentProps);
        shouldComponentUpdate(nextProps: INumericInputComponentProps, nextState: {
            value: string;
        }): boolean;
        updateValue(evt: any): void;
        render(): JSX.Element;
    }
+
+    interface IOptionsLineComponentProps {
        label: string;
        target: any;
        className?: string;
        propertyName?: string;
        options: BABYLON.IInspectableOptions[];
        noDirectUpdate?: boolean;
        onSelect?: (value: number | string) => void;
        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
        valuesAreStrings?: boolean;
        defaultIfNull?: number;
        getSelection?: (target: any) => number;
    }
    export class OptionsLineComponent extends React.Component<IOptionsLineComponentProps, {
        value: number | string;
    }> {
        private _localChange;
        private _getValue;
        constructor(props: IOptionsLineComponentProps);
        setValue(value: string | number): void;
        shouldComponentUpdate(nextProps: IOptionsLineComponentProps, nextState: {
            value: number;
        }): boolean;
        raiseOnPropertyChanged(newValue: number | string, previousValue: number | string): void;
        updateValue(valueString: string): void;
        render(): JSX.Element;
    }
+
+    export class Popup {
        static CreatePopup(title: string, windowVariableName: string, width?: number, height?: number): HTMLDivElement | null;
        static _CopyStyles(sourceDoc: HTMLDocument, targetDoc: HTMLDocument): void;
    }
+
+    export class PropertyChangedEvent {
        object: any;
        property: string;
        value: any;
        initialValue: any;
    }
+
+    interface ISliderLineComponentProps {
        label: string;
        target?: any;
        propertyName?: string;
        minimum: number;
        maximum: number;
        step: number;
        directValue?: number;
        useEuler?: boolean;
        onChange?: (value: number) => void;
        onInput?: (value: number) => void;
        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
        decimalCount?: number;
        globalState: GlobalState;
    }
    export class SliderLineComponent extends React.Component<ISliderLineComponentProps, {
        value: number;
    }> {
        private _localChange;
        constructor(props: ISliderLineComponentProps);
        shouldComponentUpdate(nextProps: ISliderLineComponentProps, nextState: {
            value: number;
        }): boolean;
        onChange(newValueString: any): void;
        onInput(newValueString: any): void;
        prepareDataToRead(value: number): number;
        render(): JSX.Element;
    }
+
+    interface ITextInputLineComponentProps {
        label: string;
        globalState: GlobalState;
        target?: any;
        propertyName?: string;
        value?: string;
        multilines?: boolean;
        onChange?: (value: string) => void;
        validator?: (value: string) => boolean;
        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
    }
    export class TextInputLineComponent extends React.Component<ITextInputLineComponentProps, {
        value: string;
    }> {
        private _localChange;
        private _onFocus;
        constructor(props: ITextInputLineComponentProps);
        shouldComponentUpdate(nextProps: ITextInputLineComponentProps, nextState: {
            value: string;
        }): boolean;
        componentWillUnmount(): void;
        raiseOnPropertyChanged(newValue: string, previousValue: string): void;
        updateValue(value: string, raisePropertyChanged: boolean): void;
        render(): JSX.Element;
    }
+
+    interface ITextLineComponentProps {
        label: string;
        value: string;
        color?: string;
        underline?: boolean;
        onLink?: () => void;
    }
    export class TextLineComponent extends React.Component<ITextLineComponentProps> {
        constructor(props: ITextLineComponentProps);
        onLink(): void;
        renderContent(): JSX.Element;
        render(): JSX.Element;
    }
+
+    interface ITextureLineComponentProps {
        texture: BABYLON.BaseTexture;
        width: number;
        height: number;
        globalState?: any;
        hideChannelSelect?: boolean;
    }
    export interface ITextureLineComponentState {
        displayRed: boolean;
        displayGreen: boolean;
        displayBlue: boolean;
        displayAlpha: boolean;
        face: number;
    }
    export class TextureLineComponent extends React.Component<ITextureLineComponentProps, ITextureLineComponentState> {
        private canvasRef;
        constructor(props: ITextureLineComponentProps);
        shouldComponentUpdate(nextProps: ITextureLineComponentProps, nextState: {
            displayRed: boolean;
            displayGreen: boolean;
            displayBlue: boolean;
            displayAlpha: boolean;
            face: number;
        }): boolean;
        componentDidMount(): void;
        componentDidUpdate(): void;
        updatePreview(): void;
        static UpdatePreview(previewCanvas: HTMLCanvasElement, texture: BABYLON.BaseTexture, width: number, options: ITextureLineComponentState, onReady?: () => void, globalState?: any): Promise<void>;
        render(): JSX.Element;
    }
+
+    interface IVector2LineComponentProps {
        label: string;
        target: any;
        propertyName: string;
        step?: number;
        onChange?: (newvalue: BABYLON.Vector2) => void;
        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
        globalState: GlobalState;
    }
    export class Vector2LineComponent extends React.Component<IVector2LineComponentProps, {
        isExpanded: boolean;
        value: BABYLON.Vector2;
    }> {
        static defaultProps: {
            step: number;
        };
        private _localChange;
        constructor(props: IVector2LineComponentProps);
        shouldComponentUpdate(nextProps: IVector2LineComponentProps, nextState: {
            isExpanded: boolean;
            value: BABYLON.Vector2;
        }): boolean;
        switchExpandState(): void;
        raiseOnPropertyChanged(previousValue: BABYLON.Vector2): void;
        updateStateX(value: number): void;
        updateStateY(value: number): void;
        render(): JSX.Element;
    }
+
+    interface IVector3LineComponentProps {
        label: string;
        target: any;
        propertyName: string;
        step?: number;
        onChange?: (newvalue: BABYLON.Vector3) => void;
        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
        globalState: GlobalState;
    }
    export class Vector3LineComponent extends React.Component<IVector3LineComponentProps, {
        isExpanded: boolean;
        value: BABYLON.Vector3;
    }> {
        static defaultProps: {
            step: number;
        };
        private _localChange;
        constructor(props: IVector3LineComponentProps);
        shouldComponentUpdate(nextProps: IVector3LineComponentProps, nextState: {
            isExpanded: boolean;
            value: BABYLON.Vector3;
        }): boolean;
        switchExpandState(): void;
        raiseOnPropertyChanged(previousValue: BABYLON.Vector3): void;
        updateVector3(): void;
        updateStateX(value: number): void;
        updateStateY(value: number): void;
        updateStateZ(value: number): void;
        render(): JSX.Element;
    }
+
+    interface IVector4LineComponentProps {
        label: string;
        target?: any;
        propertyName?: string;
        value?: BABYLON.Vector4;
        step?: number;
        onChange?: (newvalue: BABYLON.Vector4) => void;
        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
        globalState: GlobalState;
    }
    export class Vector4LineComponent extends React.Component<IVector4LineComponentProps, {
        isExpanded: boolean;
        value: BABYLON.Vector4;
    }> {
        static defaultProps: {
            step: number;
        };
        private _localChange;
        constructor(props: IVector4LineComponentProps);
        shouldComponentUpdate(nextProps: IVector4LineComponentProps, nextState: {
            isExpanded: boolean;
            value: BABYLON.Vector4;
        }): boolean;
        switchExpandState(): void;
        raiseOnPropertyChanged(previousValue: BABYLON.Vector4): void;
        updateVector4(): void;
        updateStateX(value: number): void;
        updateStateY(value: number): void;
        updateStateZ(value: number): void;
        updateStateW(value: number): void;
        render(): JSX.Element;
    }
+
+
+}