babylonjs-node-editor 5.12.1 → 5.13.2

package/babylon.nodeEditor.d.ts

@@ -216,10 +216,10 @@ declare module BABYLON.NodeEditor {
         globalState: GlobalState;
     }
     interface IPropertyTabComponentState {
-        currentNode: BABYLON.Nullable<GraphNode>;
-        currentFrame: BABYLON.Nullable<GraphFrame>;
-        currentFrameNodePort: BABYLON.Nullable<FrameNodePort>;
-        currentNodePort: BABYLON.Nullable<NodePort>;
+        currentNode: BABYLON.Nullable<BABYLON.NodeEditor.SharedUIComponents.GraphNode>;
+        currentFrame: BABYLON.Nullable<BABYLON.NodeEditor.SharedUIComponents.GraphFrame>;
+        currentFrameNodePort: BABYLON.Nullable<BABYLON.NodeEditor.SharedUIComponents.FrameNodePort>;
+        currentNodePort: BABYLON.Nullable<BABYLON.NodeEditor.SharedUIComponents.NodePort>;
         uploadInProgress: boolean;
     }
     export class PropertyTabComponent extends React.Component<IPropertyTabComponentProps, IPropertyTabComponentState> {
@@ -241,568 +241,330 @@ declare module BABYLON.NodeEditor {
     }
 
 
-    export class ClampDisplayManager implements IDisplayManager {
+    export class GlobalState {
+        nodeMaterial: BABYLON.NodeMaterial;
+        hostElement: HTMLElement;
+        hostDocument: Document;
+        hostWindow: Window;
+        stateManager: BABYLON.NodeEditor.SharedUIComponents.StateManager;
+        onBuiltObservable: BABYLON.Observable<void>;
+        onResetRequiredObservable: BABYLON.Observable<boolean>;
+        onZoomToFitRequiredObservable: BABYLON.Observable<void>;
+        onReOrganizedRequiredObservable: BABYLON.Observable<void>;
+        onLogRequiredObservable: BABYLON.Observable<LogEntry>;
+        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>;
+        onImportFrameObservable: BABYLON.Observable<any>;
+        onPopupClosedObservable: BABYLON.Observable<void>;
+        onGetNodeFromBlock: (block: BABYLON.NodeMaterialBlock) => BABYLON.NodeEditor.SharedUIComponents.GraphNode;
+        previewType: PreviewType;
+        previewFile: File;
+        particleSystemBlendMode: number;
+        listOfCustomPreviewFiles: File[];
+        rotatePreview: boolean;
+        backgroundColor: BABYLON.Color4;
+        backFaceCulling: boolean;
+        depthPrePass: boolean;
+        lockObject: BABYLON.NodeEditor.SharedUIComponents.LockObject;
+        hemisphericLight: boolean;
+        directionalLight0: boolean;
+        directionalLight1: boolean;
+        controlCamera: boolean;
+        _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();
+        storeEditorData(serializationObject: any, frame?: BABYLON.Nullable<BABYLON.NodeEditor.SharedUIComponents.GraphFrame>): void;
+    }
+
+
+    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> {
+        static readonly NodeWidth = 100;
+        private _graphCanvasRef;
+        private _diagramContainerRef;
+        private _graphCanvas;
+        private _diagramContainer;
+        private _startX;
+        private _moveInProgress;
+        private _leftWidth;
+        private _rightWidth;
+        private _previewManager;
+        private _copiedNodes;
+        private _copiedFrames;
+        private _mouseLocationX;
+        private _mouseLocationY;
+        private _onWidgetKeyUpPointer;
+        private _previewHost;
+        private _popUpWindow;
+        appendBlock(dataToAppend: BABYLON.NodeMaterialBlock | BABYLON.NodeEditor.SharedUIComponents.INodeData, recursion?: boolean): BABYLON.NodeEditor.SharedUIComponents.GraphNode;
+        addValueNode(type: string): BABYLON.NodeEditor.SharedUIComponents.GraphNode;
+        componentDidMount(): void;
+        componentWillUnmount(): void;
+        constructor(props: IGraphEditorProps);
+        reconnectNewNodes(nodeIndex: number, newNodes: BABYLON.NodeEditor.SharedUIComponents.GraphNode[], sourceNodes: BABYLON.NodeEditor.SharedUIComponents.GraphNode[], done: boolean[]): void;
+        pasteSelection(copiedNodes: BABYLON.NodeEditor.SharedUIComponents.GraphNode[], currentX: number, currentY: number, selectNew?: boolean): BABYLON.NodeEditor.SharedUIComponents.GraphNode[] | undefined;
+        zoomToFit(): void;
+        buildMaterial(autoConfigure?: boolean): void;
+        build(ignoreEditorData?: boolean): void;
+        loadGraph(): void;
+        showWaitScreen(): void;
+        hideWaitScreen(): void;
+        reOrganize(editorData?: BABYLON.Nullable<BABYLON.NodeEditor.SharedUIComponents.IEditorData>, isImportingAFrame?: boolean): void;
+        onPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
+        onPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
+        onWheel(this: any, evt: WheelEvent): void;
+        resizeColumns(evt: React.PointerEvent<HTMLDivElement>, forLeft?: boolean): void;
+        buildColumnLayout(): string;
+        emitNewBlock(blockType: string, targetX: number, targetY: number): void;
+        dropNewBlock(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;
+    }
+
+
+    export class BlockNodeData implements BABYLON.NodeEditor.SharedUIComponents.INodeData {
+        data: BABYLON.NodeMaterialBlock;
+        private _inputs;
+        private _outputs;
+        get uniqueId(): number;
+        get name(): string;
+        getClassName(): string;
+        get isInput(): boolean;
+        get inputs(): BABYLON.NodeEditor.SharedUIComponents.IPortData[];
+        get outputs(): BABYLON.NodeEditor.SharedUIComponents.IPortData[];
+        get comments(): string;
+        set comments(value: string);
+        getPortByName(name: string): BABYLON.NodeEditor.SharedUIComponents.IPortData | null;
+        dispose(): void;
+        getWarningMessage(): "" | "For optimization reasons, this block will be promoted to the vertex shader. You can force it to render in the fragment shader by setting its target to Fragment";
+        constructor(data: BABYLON.NodeMaterialBlock, nodeContainer: BABYLON.NodeEditor.SharedUIComponents.INodeContainer);
+    }
+
+
+    export class ConnectionPointPortData implements BABYLON.NodeEditor.SharedUIComponents.IPortData {
+        private _connectedPort;
+        private _nodeContainer;
+        data: BABYLON.NodeMaterialConnectionPoint;
+        get name(): string;
+        get internalName(): string;
+        get isExposedOnFrame(): boolean;
+        set isExposedOnFrame(value: boolean);
+        get exposedPortPosition(): number;
+        set exposedPortPosition(value: number);
+        get isConnected(): boolean;
+        get connectedPort(): BABYLON.Nullable<BABYLON.NodeEditor.SharedUIComponents.IPortData>;
+        set connectedPort(value: BABYLON.Nullable<BABYLON.NodeEditor.SharedUIComponents.IPortData>);
+        get direction(): BABYLON.NodeEditor.SharedUIComponents.PortDataDirection;
+        get ownerData(): import("core/Materials/Node/nodeMaterialBlock").NodeMaterialBlock;
+        get needDualDirectionValidation(): boolean;
+        get hasEndpoints(): boolean;
+        get endpoints(): BABYLON.NodeEditor.SharedUIComponents.IPortData[];
+        constructor(connectionPoint: BABYLON.NodeMaterialConnectionPoint, nodeContainer: BABYLON.NodeEditor.SharedUIComponents.INodeContainer);
+        updateDisplayName(newName: string): void;
+        connectTo(port: BABYLON.NodeEditor.SharedUIComponents.IPortData): void;
+        disconnectFrom(port: BABYLON.NodeEditor.SharedUIComponents.IPortData): void;
+        checkCompatibilityState(port: BABYLON.NodeEditor.SharedUIComponents.IPortData): 0 | BABYLON.NodeMaterialConnectionPointCompatibilityStates.TypeIncompatible | BABYLON.NodeMaterialConnectionPointCompatibilityStates.TargetIncompatible | BABYLON.NodeMaterialConnectionPointCompatibilityStates.HierarchyIssue;
+        getCompatibilityIssueMessage(issue: number, targetNode: BABYLON.NodeEditor.SharedUIComponents.GraphNode, targetPort: BABYLON.NodeEditor.SharedUIComponents.IPortData): "" | "Cannot connect two different connection types" | "Source block can only work in fragment shader whereas destination block is currently aimed for the vertex shader" | "Source block cannot be connected with one of its ancestors";
+    }
+
+
+    export class ClampDisplayManager implements BABYLON.NodeEditor.SharedUIComponents.IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
+        getHeaderText(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData): string;
         getBackgroundColor(): string;
-        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        updatePreviewContent(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData, contentArea: HTMLDivElement): void;
     }
 
 
-    export class ConditionalDisplayManager implements IDisplayManager {
+    export class ConditionalDisplayManager implements BABYLON.NodeEditor.SharedUIComponents.IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
+        getHeaderText(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData): string;
         getBackgroundColor(): string;
         updatePreviewContent(): void;
     }
 
 
-    export class DiscardDisplayManager implements IDisplayManager {
+    export class DiscardDisplayManager implements BABYLON.NodeEditor.SharedUIComponents.IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
+        getHeaderText(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData): string;
         getBackgroundColor(): 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;
+        updatePreviewContent(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData, contentArea: HTMLDivElement): void;
     }
 
 
-    export class ElbowDisplayManager implements IDisplayManager {
+    export class ElbowDisplayManager implements BABYLON.NodeEditor.SharedUIComponents.IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
-        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
-        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        getHeaderText(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData): string;
+        getBackgroundColor(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData): string;
+        updatePreviewContent(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData, contentArea: HTMLDivElement): void;
     }
 
 
-    export class GradientDisplayManager implements IDisplayManager {
+    export class GradientDisplayManager implements BABYLON.NodeEditor.SharedUIComponents.IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
-        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
-        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        getHeaderText(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData): string;
+        getBackgroundColor(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData): string;
+        updatePreviewContent(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData, contentArea: HTMLDivElement): void;
     }
 
 
-    export class ImageSourceDisplayManager implements IDisplayManager {
+    export class ImageSourceDisplayManager implements BABYLON.NodeEditor.SharedUIComponents.IDisplayManager {
         private _previewCanvas;
         private _previewImage;
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
+        getHeaderText(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData): string;
         getBackgroundColor(): string;
-        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        updatePreviewContent(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData, contentArea: HTMLDivElement): void;
     }
 
 
-    export class InputDisplayManager implements IDisplayManager {
-        getHeaderClass(block: BABYLON.NodeMaterialBlock): "" | "constant" | "inspector";
+    export class InputDisplayManager implements BABYLON.NodeEditor.SharedUIComponents.IDisplayManager {
+        getHeaderClass(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData): "" | "constant" | "inspector";
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
+        getHeaderText(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData): string;
         static GetBaseType(type: BABYLON.NodeMaterialBlockConnectionPointTypes): string;
-        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
-        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        getBackgroundColor(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData): string;
+        updatePreviewContent(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData, contentArea: HTMLDivElement): void;
     }
 
 
-    export class OutputDisplayManager implements IDisplayManager {
+    export class OutputDisplayManager implements BABYLON.NodeEditor.SharedUIComponents.IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
+        getHeaderText(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData): string;
         getBackgroundColor(): string;
-        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        updatePreviewContent(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData, contentArea: HTMLDivElement): void;
     }
 
 
-    export class PBRDisplayManager implements IDisplayManager {
+    export class PBRDisplayManager implements BABYLON.NodeEditor.SharedUIComponents.IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
+        getHeaderText(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData): string;
         getBackgroundColor(): string;
-        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        updatePreviewContent(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData, contentArea: HTMLDivElement): void;
     }
 
 
-    export class RemapDisplayManager implements IDisplayManager {
+    export class RemapDisplayManager implements BABYLON.NodeEditor.SharedUIComponents.IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
+        getHeaderText(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData): string;
         getBackgroundColor(): string;
         private _extractInputValue;
-        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        updatePreviewContent(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData, contentArea: HTMLDivElement): void;
     }
 
 
-    export class TextureDisplayManager implements IDisplayManager {
+    export class TextureDisplayManager implements BABYLON.NodeEditor.SharedUIComponents.IDisplayManager {
         private _previewCanvas;
         private _previewImage;
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
-        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
-        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        getHeaderText(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData): string;
+        getBackgroundColor(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData): string;
+        updatePreviewContent(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData, contentArea: HTMLDivElement): void;
     }
 
 
-    export class TrigonometryDisplayManager implements IDisplayManager {
+    export class TrigonometryDisplayManager implements BABYLON.NodeEditor.SharedUIComponents.IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
+        getHeaderText(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData): string;
         getBackgroundColor(): string;
-        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        updatePreviewContent(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData, contentArea: HTMLDivElement): void;
     }
 
 
-    export class DisplayLedger {
-        static RegisteredControls: {
-            [key: string]: any;
-        };
+    export class ColorMergerPropertyTabComponent extends React.Component<BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps> {
+        constructor(props: BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps);
+        render(): JSX.Element;
     }
 
 
-    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 class ConditionalPropertyTabComponent extends React.Component<BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps> {
+        constructor(props: BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps);
+        render(): JSX.Element;
     }
 
 
-    export interface IGraphCanvasComponentProps {
+    export interface IFrameNodePortPropertyTabComponentProps {
+        stateManager: BABYLON.NodeEditor.SharedUIComponents.StateManager;
         globalState: GlobalState;
-        onEmitNewBlock: (block: BABYLON.NodeMaterialBlock) => GraphNode;
+        frameNodePort: BABYLON.NodeEditor.SharedUIComponents.FrameNodePort;
+        frame: BABYLON.NodeEditor.SharedUIComponents.GraphFrame;
     }
-    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 _selectedFrames;
-        private _frameCandidate;
-        private _frames;
-        private _altKeyIsPressed;
-        private _multiKeyIsPressed;
-        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 selectedFrames(): GraphFrame[];
-        get selectedPort(): BABYLON.Nullable<NodePort>;
-        get canvasContainer(): HTMLDivElement;
-        get hostCanvas(): HTMLDivElement;
-        get svgCanvas(): HTMLElement;
-        get selectionContainer(): HTMLDivElement;
-        get frameContainer(): HTMLDivElement;
-        private _selectedFrameAndNodesConflict;
-        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;
+    export class FrameNodePortPropertyTabComponent extends React.Component<IFrameNodePortPropertyTabComponentProps, {
+        port: BABYLON.NodeEditor.SharedUIComponents.FrameNodePort;
+    }> {
+        private _onFramePortPositionChangedObserver;
+        private _onSelectionChangedObserver;
+        constructor(props: IFrameNodePortPropertyTabComponentProps);
+        componentWillUnmount(): void;
+        render(): JSX.Element;
+    }
+
+
+    export interface IFramePropertyTabComponentProps {
+        globalState: GlobalState;
+        frame: BABYLON.NodeEditor.SharedUIComponents.GraphFrame;
+    }
+    export class FramePropertyTabComponent extends React.Component<IFramePropertyTabComponentProps> {
+        private _onFrameExpandStateChangedObserver;
+        constructor(props: IFramePropertyTabComponentProps);
         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;
-        connectNodes(nodeA: GraphNode, pointA: BABYLON.NodeMaterialConnectionPoint, nodeB: GraphNode, pointB: BABYLON.NodeMaterialConnectionPoint): void;
-        processEditorData(editorData: IEditorData): void;
-        addFrame(frameData: IFrameData): void;
+        componentWillUnmount(): void;
         render(): JSX.Element;
     }
 
 
-    export enum FramePortPosition {
-        Top = 0,
-        Middle = 1,
-        Bottom = 2
+    export class GenericPropertyComponent extends React.Component<BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps> {
+        constructor(props: BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps);
+        render(): JSX.Element;
     }
-    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;
-        _moveFrame(offsetX: number, offsetY: number): void;
-        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);
-        setIsSelected(value: boolean, marqueeSelection: boolean): void;
-        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(evt: MouseEvent): 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<ISelectionChangedOptions>>>;
-        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);
+    export class GeneralPropertyTabComponent extends React.Component<BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps> {
+        constructor(props: BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps);
         render(): JSX.Element;
     }
-    export class GenericPropertyTabComponent extends React.Component<IPropertyComponentProps> {
-        constructor(props: IPropertyComponentProps);
+    export class GenericPropertyTabComponent extends React.Component<BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps> {
+        constructor(props: BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps);
         forceRebuild(notifiers?: {
             rebuild?: boolean;
             update?: boolean;
@@ -813,9 +575,9 @@ declare module BABYLON.NodeEditor {
     }
 
 
-    export class GradientPropertyTabComponent extends React.Component<IPropertyComponentProps> {
+    export class GradientPropertyTabComponent extends React.Component<BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps> {
         private _onValueChangedObserver;
-        constructor(props: IPropertyComponentProps);
+        constructor(props: BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps);
         componentDidMount(): void;
         componentWillUnmount(): void;
         forceRebuild(): void;
@@ -828,7 +590,7 @@ declare module BABYLON.NodeEditor {
 
 
     interface IGradientStepComponentProps {
-        globalState: GlobalState;
+        stateManager: BABYLON.NodeEditor.SharedUIComponents.StateManager;
         step: BABYLON.GradientBlockColorStep;
         lineIndex: number;
         onDelete: () => void;
@@ -847,12 +609,12 @@ declare module BABYLON.NodeEditor {
     }
 
 
-    export class ImageSourcePropertyTabComponent extends React.Component<IPropertyComponentProps, {
+    export class ImageSourcePropertyTabComponent extends React.Component<BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps, {
         isEmbedded: boolean;
     }> {
         get imageSourceBlock(): BABYLON.ImageSourceBlock;
-        constructor(props: IPropertyComponentProps);
-        UNSAFE_componentWillUpdate(nextProps: IPropertyComponentProps, nextState: {
+        constructor(props: BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps);
+        UNSAFE_componentWillUpdate(nextProps: BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps, nextState: {
             isEmbedded: boolean;
             loadAsCubeTexture: boolean;
         }): void;
@@ -870,9 +632,9 @@ declare module BABYLON.NodeEditor {
     }
 
 
-    export class InputPropertyTabComponent extends React.Component<IPropertyComponentProps> {
+    export class InputPropertyTabComponent extends React.Component<BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps> {
         private _onValueChangedObserver;
-        constructor(props: IPropertyComponentProps);
+        constructor(props: BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps);
         componentDidMount(): void;
         componentWillUnmount(): void;
         renderValue(globalState: GlobalState): JSX.Element | null;
@@ -881,19 +643,19 @@ declare module BABYLON.NodeEditor {
     }
 
 
-    export class LightInformationPropertyTabComponent extends React.Component<IPropertyComponentProps> {
+    export class LightInformationPropertyTabComponent extends React.Component<BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps> {
         render(): JSX.Element;
     }
 
 
-    export class LightPropertyTabComponent extends React.Component<IPropertyComponentProps> {
+    export class LightPropertyTabComponent extends React.Component<BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps> {
         render(): JSX.Element;
     }
 
 
     export interface IFrameNodePortPropertyTabComponentProps {
-        globalState: GlobalState;
-        nodePort: NodePort;
+        stateManager: BABYLON.NodeEditor.SharedUIComponents.StateManager;
+        nodePort: BABYLON.NodeEditor.SharedUIComponents.NodePort;
     }
     export class NodePortPropertyTabComponent extends React.Component<IFrameNodePortPropertyTabComponentProps> {
         private _onSelectionChangedObserver;
@@ -904,22 +666,16 @@ declare module BABYLON.NodeEditor {
     }
 
 
-    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, {
+    export class TexturePropertyTabComponent extends React.Component<BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps, {
         isEmbedded: boolean;
         loadAsCubeTexture: boolean;
         textureIsPrefiltered: boolean;
     }> {
         get textureBlock(): AnyTexture;
-        constructor(props: IPropertyComponentProps);
-        UNSAFE_componentWillUpdate(nextProps: IPropertyComponentProps, nextState: {
+        constructor(props: BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps);
+        UNSAFE_componentWillUpdate(nextProps: BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps, nextState: {
             isEmbedded: boolean;
             loadAsCubeTexture: boolean;
         }): void;
@@ -937,177 +693,51 @@ declare module BABYLON.NodeEditor {
     }
 
 
-    export class TransformPropertyTabComponent extends React.Component<IPropertyComponentProps> {
-        constructor(props: IPropertyComponentProps);
+    export class TransformPropertyTabComponent extends React.Component<BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps> {
+        constructor(props: BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps);
         render(): JSX.Element;
     }
 
 
-    export class TrigonometryPropertyTabComponent extends React.Component<IPropertyComponentProps> {
-        constructor(props: IPropertyComponentProps);
+    export class TrigonometryPropertyTabComponent extends React.Component<BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps> {
+        constructor(props: BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps);
         render(): JSX.Element;
     }
 
 
-    export class VectorMergerPropertyTabComponent extends React.Component<IPropertyComponentProps> {
-        constructor(props: IPropertyComponentProps);
+    export class VectorMergerPropertyTabComponent extends React.Component<BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps> {
+        constructor(props: BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps);
         render(): JSX.Element;
     }
 
 
-    export class PropertyLedger {
-        static RegisteredControls: {
-            [key: string]: React.ComponentClass<IPropertyComponentProps>;
-        };
-    }
+    export const RegisterDefaultInput: (stateManager: BABYLON.NodeEditor.SharedUIComponents.StateManager) => void;
 
 
-    export class ISelectionChangedOptions {
-        selection: BABYLON.Nullable<GraphNode | NodeLink | GraphFrame | NodePort | FramePortData>;
-        forceKeepSelection?: boolean;
-        marqueeSelection?: boolean;
-    }
-    export class GlobalState {
-        nodeMaterial: BABYLON.NodeMaterial;
-        hostElement: HTMLElement;
-        hostDocument: HTMLDocument;
-        hostWindow: Window;
-        onNewNodeCreatedObservable: BABYLON.Observable<GraphNode>;
-        onSelectionChangedObservable: BABYLON.Observable<BABYLON.Nullable<ISelectionChangedOptions>>;
-        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>;
-        onNewBlockRequiredObservable: BABYLON.Observable<{
-            type: string;
-            targetX: number;
-            targetY: number;
-            needRepositioning?: boolean | undefined;
-        }>;
-        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> {
-        static readonly NodeWidth = 100;
-        private _graphCanvasRef;
-        private _diagramContainerRef;
-        private _graphCanvas;
-        private _diagramContainer;
-        private _startX;
-        private _moveInProgress;
-        private _leftWidth;
-        private _rightWidth;
-        private _blocks;
-        private _previewManager;
-        private _copiedNodes;
-        private _copiedFrames;
-        private _mouseLocationX;
-        private _mouseLocationY;
-        private _onWidgetKeyUpPointer;
-        private _previewHost;
-        private _popUpWindow;
-        /**
-         * Creates a node and recursivly creates its parent nodes from it's input
-         * @param block
-         * @param recursion
-         */
-        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;
-        onWheel(this: any, evt: WheelEvent): void;
-        resizeColumns(evt: React.PointerEvent<HTMLDivElement>, forLeft?: boolean): void;
-        buildColumnLayout(): string;
-        emitNewBlock(blockType: string, targetX: number, targetY: number): void;
-        dropNewBlock(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 {
+    export const RegisterElbowSupport: (stateManager: BABYLON.NodeEditor.SharedUIComponents.StateManager) => void;
+
+
+    export const RegisterExportData: (stateManager: BABYLON.NodeEditor.SharedUIComponents.StateManager) => void;
+
+
+    export const RegisterNodePortDesign: (stateManager: BABYLON.NodeEditor.SharedUIComponents.StateManager) => void;
+
+
+    export const RegisterToDisplayManagers: () => void;
+
+
+    export const RegisterToPropertyTabManagers: () => void;
+
+
+    export const RegisterTypeLedger: () => void;
+
+
+
+
+    /**
+     * Interface used to specify creation options for the node editor
+     */
+    export interface INodeEditorOptions {
         nodeMaterial: BABYLON.NodeMaterial;
         hostElement?: HTMLElement;
         customSave?: {
@@ -1129,34 +759,6 @@ declare module BABYLON.NodeEditor {
     }
 
 
-    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;
     }
@@ -1166,24 +768,13 @@ declare module BABYLON.NodeEditor {
 
 
     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 UpdateLocations(material: BABYLON.NodeMaterial, globalState: GlobalState, frame?: BABYLON.Nullable<BABYLON.NodeEditor.SharedUIComponents.GraphFrame>): void;
+        static Serialize(material: BABYLON.NodeMaterial, globalState: GlobalState, frame?: BABYLON.Nullable<BABYLON.NodeEditor.SharedUIComponents.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;
@@ -1211,51 +802,6 @@ declare module BABYLON.NodeEditor {
     }
 
 
-    export interface IColor3LineComponentProps {
-        label: string;
-        target: any;
-        propertyName: string;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
-        onChange?: () => void;
-        globalState: GlobalState;
-    }
-    interface IColor3LineComponentState {
-        isExpanded: boolean;
-    }
-    export class Color3LineComponent extends React.Component<IColor3LineComponentProps, IColor3LineComponentState> {
-        constructor(props: IColor3LineComponentProps);
-        onChange(newValue: string): void;
-        switchExpandState(): void;
-        updateColor(newValue: BABYLON.Color3 | BABYLON.Color4): void;
-        modifyColor(modifier: (previous: BABYLON.Color3 | BABYLON.Color4) => void): void;
-        getCurrentColor(): BABYLON.Color3 | BABYLON.Color4;
-        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;
-    }> {
-        constructor(props: IColor4LineComponentProps);
-        onChange(newValue: string): void;
-        switchExpandState(): void;
-        updateColor(newValue: BABYLON.Color4): void;
-        modifyColor(modifier: (previous: BABYLON.Color4) => void): void;
-        getCurrentColor(): BABYLON.Color4;
-        copyToClipboard(): void;
-        render(): JSX.Element;
-    }
-
-
     export interface IColorPickerComponentProps {
         value: BABYLON.Color4 | BABYLON.Color3;
         onColorChanged: (newOne: string) => void;
@@ -1386,37 +932,6 @@ declare module BABYLON.NodeEditor {
     }
 
 
-    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;
     }
@@ -1452,35 +967,6 @@ declare module BABYLON.NodeEditor {
     }
 
 
-    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;
@@ -1525,34 +1011,7 @@ declare module BABYLON.NodeEditor {
     }
 
 
-    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 {
+    interface ITextLineComponentProps {
         label: string;
         value: string;
         color?: string;
@@ -1593,102 +1052,6 @@ declare module BABYLON.NodeEditor {
     }
 
 
-    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;
-    }
-
-
 
 }
 declare module BABYLON.NodeEditor.SharedUIComponents {
@@ -1876,6 +1239,7 @@ declare module BABYLON.NodeEditor.SharedUIComponents {
         onClick: () => void;
         icon?: string;
         iconLabel?: string;
+        isDisabled?: boolean;
     }
     export class ButtonLineComponent extends React.Component<IButtonLineComponentProps> {
         constructor(props: IButtonLineComponentProps);
@@ -1938,7 +1302,7 @@ declare module BABYLON.NodeEditor.SharedUIComponents {
         icon?: string;
         lockObject?: BABYLON.NodeEditor.SharedUIComponents.LockObject;
         iconLabel?: string;
-        onValueChange?: (value: string) => void;
+        onChange?: () => void;
     }
     export class Color3LineComponent extends React.Component<IColor3LineComponentProps> {
         render(): JSX.Element;
@@ -2333,6 +1697,42 @@ declare module BABYLON.NodeEditor.SharedUIComponents {
 
 
 
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        interface IMatrixLineComponentProps {
+        label: string;
+        target: any;
+        propertyName: string;
+        step?: number;
+        onChange?: (newValue: BABYLON.Matrix) => void;
+        onModeChange?: (mode: number) => void;
+        onPropertyChangedObservable?: BABYLON.Observable<BABYLON.NodeEditor.SharedUIComponents.PropertyChangedEvent>;
+        mode?: number;
+    }
+    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;
+    }
+
+
+
 }
 declare module BABYLON.NodeEditor {
 
@@ -2394,24 +1794,29 @@ declare module BABYLON.NodeEditor.SharedUIComponents {
         propertyName: string;
         options: BABYLON.IInspectableOptions[];
         noDirectUpdate?: boolean;
-        onSelect?: (value: number) => void;
-        extractValue?: () => number;
+        onSelect?: (value: number | string) => void;
+        extractValue?: (target: any) => number | string;
         onPropertyChangedObservable?: BABYLON.Observable<BABYLON.NodeEditor.SharedUIComponents.PropertyChangedEvent>;
         allowNullValue?: boolean;
         icon?: string;
         iconLabel?: string;
+        className?: string;
+        valuesAreStrings?: boolean;
+        defaultIfNull?: number;
     }
     export class OptionsLineComponent extends React.Component<IOptionsLineComponentProps, {
-        value: number;
+        value: number | string;
     }> {
         private _localChange;
         private _remapValueIn;
         private _remapValueOut;
+        private _getValue;
         constructor(props: IOptionsLineComponentProps);
         shouldComponentUpdate(nextProps: IOptionsLineComponentProps, nextState: {
             value: number;
         }): boolean;
         raiseOnPropertyChanged(newValue: number, previousValue: number): void;
+        setValue(value: string | number): void;
         updateValue(valueString: string): void;
         render(): JSX.Element;
     }
@@ -2540,6 +1945,8 @@ declare module BABYLON.NodeEditor.SharedUIComponents {
         max?: number;
         placeholder?: string;
         unit?: React.ReactNode;
+        validator?: (value: string) => boolean;
+        multilines?: boolean;
     }
     export class TextInputLineComponent extends React.Component<ITextInputLineComponentProps, {
         value: string;
@@ -2711,14 +2118,15 @@ declare module BABYLON.NodeEditor {
 declare module BABYLON.NodeEditor.SharedUIComponents {
         interface IVector4LineComponentProps {
         label: string;
-        target: any;
-        propertyName: string;
+        target?: any;
+        propertyName?: string;
         step?: number;
         onChange?: (newvalue: BABYLON.Vector4) => void;
         useEuler?: boolean;
         onPropertyChangedObservable?: BABYLON.Observable<BABYLON.NodeEditor.SharedUIComponents.PropertyChangedEvent>;
         icon?: string;
         iconLabel?: string;
+        value?: BABYLON.Vector4;
     }
     export class Vector4LineComponent extends React.Component<IVector4LineComponentProps, {
         isExpanded: boolean;
@@ -2746,6 +2154,667 @@ declare module BABYLON.NodeEditor.SharedUIComponents {
 
 
 
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export class DisplayLedger {
+        static RegisteredControls: {
+            [key: string]: any;
+        };
+    }
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export class FrameNodePort extends BABYLON.NodeEditor.SharedUIComponents.NodePort {
+        portData: BABYLON.NodeEditor.SharedUIComponents.IPortData;
+        node: BABYLON.NodeEditor.SharedUIComponents.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(): BABYLON.NodeEditor.SharedUIComponents.FramePortPosition;
+        set framePortPosition(position: BABYLON.NodeEditor.SharedUIComponents.FramePortPosition);
+        constructor(portContainer: HTMLElement, portData: BABYLON.NodeEditor.SharedUIComponents.IPortData, node: BABYLON.NodeEditor.SharedUIComponents.GraphNode, stateManager: BABYLON.NodeEditor.SharedUIComponents.StateManager, isInput: boolean, framePortId: number, parentFrameId: number);
+        static CreateFrameNodePortElement(portData: BABYLON.NodeEditor.SharedUIComponents.IPortData, node: BABYLON.NodeEditor.SharedUIComponents.GraphNode, root: HTMLElement, displayManager: BABYLON.Nullable<BABYLON.NodeEditor.SharedUIComponents.IDisplayManager>, stateManager: BABYLON.NodeEditor.SharedUIComponents.StateManager, isInput: boolean, framePortId: number, parentFrameId: number): FrameNodePort;
+    }
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export interface IGraphCanvasComponentProps {
+        stateManager: BABYLON.NodeEditor.SharedUIComponents.StateManager;
+        onEmitNewNode: (nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData) => BABYLON.NodeEditor.SharedUIComponents.GraphNode;
+    }
+    export class GraphCanvasComponent extends React.Component<IGraphCanvasComponentProps> implements BABYLON.NodeEditor.SharedUIComponents.INodeContainer {
+        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 _selectedFrames;
+        private _frameCandidate;
+        private _frames;
+        private _nodeDataContentList;
+        private _altKeyIsPressed;
+        private _multiKeyIsPressed;
+        private _oldY;
+        _frameIsMoving: boolean;
+        _isLoading: boolean;
+        get gridSize(): number;
+        set gridSize(value: number);
+        get stateManager(): BABYLON.NodeEditor.SharedUIComponents.StateManager;
+        get nodes(): BABYLON.NodeEditor.SharedUIComponents.GraphNode[];
+        get links(): BABYLON.NodeEditor.SharedUIComponents.NodeLink[];
+        get frames(): BABYLON.NodeEditor.SharedUIComponents.GraphFrame[];
+        get zoom(): number;
+        set zoom(value: number);
+        get x(): number;
+        set x(value: number);
+        get y(): number;
+        set y(value: number);
+        get selectedNodes(): BABYLON.NodeEditor.SharedUIComponents.GraphNode[];
+        get selectedLink(): BABYLON.Nullable<BABYLON.NodeEditor.SharedUIComponents.NodeLink>;
+        get selectedFrames(): BABYLON.NodeEditor.SharedUIComponents.GraphFrame[];
+        get selectedPort(): BABYLON.Nullable<BABYLON.NodeEditor.SharedUIComponents.NodePort>;
+        get canvasContainer(): HTMLDivElement;
+        get hostCanvas(): HTMLDivElement;
+        get svgCanvas(): HTMLElement;
+        get selectionContainer(): HTMLDivElement;
+        get frameContainer(): HTMLDivElement;
+        private _selectedFrameAndNodesConflict;
+        constructor(props: IGraphCanvasComponentProps);
+        getCachedData(): any[];
+        removeDataFromCache(data: any): void;
+        createNodeFromObject(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData, onNodeCreated: (data: any) => void, recursion?: boolean): BABYLON.NodeEditor.SharedUIComponents.GraphNode;
+        getGridPosition(position: number, useCeil?: boolean): number;
+        getGridPositionCeil(position: number): number;
+        updateTransform(): void;
+        onKeyUp(): void;
+        findNodeFromData(data: any): BABYLON.NodeEditor.SharedUIComponents.GraphNode;
+        reset(): void;
+        connectPorts(pointA: BABYLON.NodeEditor.SharedUIComponents.IPortData, pointB: BABYLON.NodeEditor.SharedUIComponents.IPortData): void;
+        removeLink(link: BABYLON.NodeEditor.SharedUIComponents.NodeLink): void;
+        appendNode(nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData): BABYLON.NodeEditor.SharedUIComponents.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;
+        connectNodes(nodeA: BABYLON.NodeEditor.SharedUIComponents.GraphNode, pointA: BABYLON.NodeEditor.SharedUIComponents.IPortData, nodeB: BABYLON.NodeEditor.SharedUIComponents.GraphNode, pointB: BABYLON.NodeEditor.SharedUIComponents.IPortData): void;
+        processEditorData(editorData: BABYLON.NodeEditor.SharedUIComponents.IEditorData): void;
+        reOrganize(editorData?: BABYLON.Nullable<BABYLON.NodeEditor.SharedUIComponents.IEditorData>, isImportingAFrame?: boolean): void;
+        addFrame(frameData: BABYLON.NodeEditor.SharedUIComponents.IFrameData): void;
+        render(): JSX.Element;
+    }
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        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(): BABYLON.NodeEditor.SharedUIComponents.GraphNode[];
+        get ports(): BABYLON.NodeEditor.SharedUIComponents.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: BABYLON.NodeEditor.SharedUIComponents.GraphCanvasComponent, doNotCaptureNodes?: boolean);
+        refresh(): void;
+        addNode(node: BABYLON.NodeEditor.SharedUIComponents.GraphNode): void;
+        removeNode(node: BABYLON.NodeEditor.SharedUIComponents.GraphNode): void;
+        syncNode(node: BABYLON.NodeEditor.SharedUIComponents.GraphNode): void;
+        cleanAccumulation(): void;
+        private _onDown;
+        move(newX: number, newY: number, align?: boolean): void;
+        private _onUp;
+        _moveFrame(offsetX: number, offsetY: number): void;
+        private _onMove;
+        moveFramePortUp(nodePort: BABYLON.NodeEditor.SharedUIComponents.FrameNodePort): void;
+        private _movePortUp;
+        moveFramePortDown(nodePort: BABYLON.NodeEditor.SharedUIComponents.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): BABYLON.NodeEditor.SharedUIComponents.IFrameData;
+        export(): void;
+        adjustPorts(): void;
+        static Parse(serializationData: BABYLON.NodeEditor.SharedUIComponents.IFrameData, canvas: BABYLON.NodeEditor.SharedUIComponents.GraphCanvasComponent, map?: {
+            [key: number]: number;
+        }): GraphFrame;
+    }
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        /// <reference types="react" />
+    export class GraphNode {
+        content: BABYLON.NodeEditor.SharedUIComponents.INodeData;
+        private _visual;
+        private _headerContainer;
+        private _warning;
+        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 _stateManager;
+        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(): BABYLON.NodeEditor.SharedUIComponents.NodePort[];
+        get inputPorts(): BABYLON.NodeEditor.SharedUIComponents.NodePort[];
+        get links(): BABYLON.NodeEditor.SharedUIComponents.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);
+        setIsSelected(value: boolean, marqueeSelection: boolean): void;
+        constructor(content: BABYLON.NodeEditor.SharedUIComponents.INodeData, stateManager: BABYLON.NodeEditor.SharedUIComponents.StateManager);
+        isOverlappingFrame(frame: BABYLON.NodeEditor.SharedUIComponents.GraphFrame): boolean;
+        getPortForPortData(portData: BABYLON.NodeEditor.SharedUIComponents.IPortData): BABYLON.NodeEditor.SharedUIComponents.NodePort | null;
+        getPortDataForPortDataContent(data: any): BABYLON.NodeEditor.SharedUIComponents.IPortData | null;
+        getLinksForPortDataContent(data: any): BABYLON.NodeEditor.SharedUIComponents.NodeLink[];
+        getLinksForPortData(portData: BABYLON.NodeEditor.SharedUIComponents.IPortData): BABYLON.NodeEditor.SharedUIComponents.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: BABYLON.NodeEditor.SharedUIComponents.GraphCanvasComponent): void;
+        dispose(): void;
+    }
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export interface IDisplayManager {
+        getHeaderClass(data: BABYLON.NodeEditor.SharedUIComponents.INodeData): string;
+        shouldDisplayPortLabels(data: BABYLON.NodeEditor.SharedUIComponents.IPortData): boolean;
+        updatePreviewContent(data: BABYLON.NodeEditor.SharedUIComponents.INodeData, contentArea: HTMLDivElement): void;
+        getBackgroundColor(data: BABYLON.NodeEditor.SharedUIComponents.INodeData): string;
+        getHeaderText(data: BABYLON.NodeEditor.SharedUIComponents.INodeData): string;
+    }
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export interface INodeContainer {
+        nodes: BABYLON.NodeEditor.SharedUIComponents.GraphNode[];
+        appendNode(data: BABYLON.NodeEditor.SharedUIComponents.INodeData): BABYLON.NodeEditor.SharedUIComponents.GraphNode;
+    }
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export interface INodeData {
+        data: any;
+        name: string;
+        uniqueId: number;
+        isInput: boolean;
+        comments: string;
+        getWarningMessage: () => string;
+        getClassName: () => string;
+        dispose: () => void;
+        getPortByName: (name: string) => BABYLON.Nullable<BABYLON.NodeEditor.SharedUIComponents.IPortData>;
+        inputs: BABYLON.NodeEditor.SharedUIComponents.IPortData[];
+        outputs: BABYLON.NodeEditor.SharedUIComponents.IPortData[];
+    }
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        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 BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export enum PortDataDirection {
+        /** Input */
+        Input = 0,
+        /** Output */
+        Output = 1
+    }
+    export interface IPortData {
+        data: any;
+        name: string;
+        internalName: string;
+        isExposedOnFrame: boolean;
+        exposedPortPosition: number;
+        isConnected: boolean;
+        direction: PortDataDirection;
+        ownerData: any;
+        connectedPort: BABYLON.Nullable<IPortData>;
+        needDualDirectionValidation: boolean;
+        hasEndpoints: boolean;
+        endpoints: BABYLON.Nullable<IPortData[]>;
+        updateDisplayName: (newName: string) => void;
+        connectTo: (port: IPortData) => void;
+        disconnectFrom: (port: IPortData) => void;
+        checkCompatibilityState(port: IPortData): number;
+        getCompatibilityIssueMessage(issue: number, targetNode: BABYLON.NodeEditor.SharedUIComponents.GraphNode, targetPort: IPortData): string;
+    }
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export interface IPropertyComponentProps {
+        stateManager: BABYLON.NodeEditor.SharedUIComponents.StateManager;
+        nodeData: BABYLON.NodeEditor.SharedUIComponents.INodeData;
+    }
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export interface ISelectionChangedOptions {
+        selection: BABYLON.Nullable<BABYLON.NodeEditor.SharedUIComponents.GraphNode | BABYLON.NodeEditor.SharedUIComponents.NodeLink | BABYLON.NodeEditor.SharedUIComponents.GraphFrame | BABYLON.NodeEditor.SharedUIComponents.NodePort | BABYLON.NodeEditor.SharedUIComponents.FramePortData>;
+        forceKeepSelection?: boolean;
+        marqueeSelection?: boolean;
+    }
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        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(): BABYLON.NodeEditor.SharedUIComponents.FrameNodePort | BABYLON.NodeEditor.SharedUIComponents.NodePort;
+        get portB(): BABYLON.NodeEditor.SharedUIComponents.FrameNodePort | BABYLON.NodeEditor.SharedUIComponents.NodePort | undefined;
+        get nodeA(): BABYLON.NodeEditor.SharedUIComponents.GraphNode;
+        get nodeB(): BABYLON.NodeEditor.SharedUIComponents.GraphNode | undefined;
+        update(endX?: number, endY?: number, straight?: boolean): void;
+        constructor(graphCanvas: BABYLON.NodeEditor.SharedUIComponents.GraphCanvasComponent, portA: BABYLON.NodeEditor.SharedUIComponents.NodePort, nodeA: BABYLON.NodeEditor.SharedUIComponents.GraphNode, portB?: BABYLON.NodeEditor.SharedUIComponents.NodePort, nodeB?: BABYLON.NodeEditor.SharedUIComponents.GraphNode);
+        onClick(evt: MouseEvent): void;
+        dispose(notify?: boolean): void;
+    }
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export class NodePort {
+        portData: BABYLON.NodeEditor.SharedUIComponents.IPortData;
+        node: BABYLON.NodeEditor.SharedUIComponents.GraphNode;
+        protected _element: HTMLDivElement;
+        protected _img: HTMLImageElement;
+        protected _stateManager: BABYLON.NodeEditor.SharedUIComponents.StateManager;
+        protected _portLabelElement: Element;
+        protected _onCandidateLinkMovedObserver: BABYLON.Nullable<BABYLON.Observer<BABYLON.Nullable<BABYLON.Vector2>>>;
+        protected _onSelectionChangedObserver: BABYLON.Nullable<BABYLON.Observer<BABYLON.Nullable<BABYLON.NodeEditor.SharedUIComponents.ISelectionChangedOptions>>>;
+        protected _exposedOnFrame: boolean;
+        delegatedPort: BABYLON.Nullable<BABYLON.NodeEditor.SharedUIComponents.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, portData: BABYLON.NodeEditor.SharedUIComponents.IPortData, node: BABYLON.NodeEditor.SharedUIComponents.GraphNode, stateManager: BABYLON.NodeEditor.SharedUIComponents.StateManager);
+        dispose(): void;
+        static CreatePortElement(portData: BABYLON.NodeEditor.SharedUIComponents.IPortData, node: BABYLON.NodeEditor.SharedUIComponents.GraphNode, root: HTMLElement, displayManager: BABYLON.Nullable<BABYLON.NodeEditor.SharedUIComponents.IDisplayManager>, stateManager: BABYLON.NodeEditor.SharedUIComponents.StateManager): NodePort;
+    }
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export class PropertyLedger {
+        static DefaultControl: React.ComponentClass<BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps>;
+        static RegisteredControls: {
+            [key: string]: React.ComponentClass<BABYLON.NodeEditor.SharedUIComponents.IPropertyComponentProps>;
+        };
+    }
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export class StateManager {
+        data: any;
+        hostDocument: Document;
+        lockObject: any;
+        onSelectionChangedObservable: BABYLON.Observable<BABYLON.Nullable<BABYLON.NodeEditor.SharedUIComponents.ISelectionChangedOptions>>;
+        onFrameCreatedObservable: BABYLON.Observable<BABYLON.NodeEditor.SharedUIComponents.GraphFrame>;
+        onUpdateRequiredObservable: BABYLON.Observable<any>;
+        onGraphNodeRemovalObservable: BABYLON.Observable<BABYLON.NodeEditor.SharedUIComponents.GraphNode>;
+        onSelectionBoxMoved: BABYLON.Observable<ClientRect | DOMRect>;
+        onCandidateLinkMoved: BABYLON.Observable<BABYLON.Nullable<BABYLON.Vector2>>;
+        onCandidatePortSelectedObservable: BABYLON.Observable<BABYLON.Nullable<BABYLON.NodeEditor.SharedUIComponents.FrameNodePort | BABYLON.NodeEditor.SharedUIComponents.NodePort>>;
+        onNewNodeCreatedObservable: BABYLON.Observable<BABYLON.NodeEditor.SharedUIComponents.GraphNode>;
+        onRebuildRequiredObservable: BABYLON.Observable<boolean>;
+        onErrorMessageDialogRequiredObservable: BABYLON.Observable<string>;
+        onExposePortOnFrameObservable: BABYLON.Observable<BABYLON.NodeEditor.SharedUIComponents.GraphNode>;
+        onGridSizeChanged: BABYLON.Observable<void>;
+        onNewBlockRequiredObservable: BABYLON.Observable<{
+            type: string;
+            targetX: number;
+            targetY: number;
+            needRepositioning?: boolean | undefined;
+        }>;
+        exportData: (data: any) => string;
+        isElbowConnectionAllowed: (nodeA: BABYLON.NodeEditor.SharedUIComponents.FrameNodePort | BABYLON.NodeEditor.SharedUIComponents.NodePort, nodeB: BABYLON.NodeEditor.SharedUIComponents.FrameNodePort | BABYLON.NodeEditor.SharedUIComponents.NodePort) => boolean;
+        applyNodePortDesign: (data: BABYLON.NodeEditor.SharedUIComponents.IPortData, element: HTMLElement, img: HTMLImageElement) => void;
+        storeEditorData: (serializationObject: any, frame?: BABYLON.Nullable<BABYLON.NodeEditor.SharedUIComponents.GraphFrame>) => void;
+        getEditorDataMap: () => {
+            [key: number]: number;
+        };
+        createDefaultInputData: (rootData: any, portData: BABYLON.NodeEditor.SharedUIComponents.IPortData, nodeContainer: BABYLON.NodeEditor.SharedUIComponents.INodeContainer) => {
+            data: BABYLON.NodeEditor.SharedUIComponents.INodeData;
+            name: string;
+        };
+    }
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export const IsFramePortData: (variableToCheck: any) => variableToCheck is BABYLON.NodeEditor.SharedUIComponents.FramePortData;
+    export const RefreshNode: (node: BABYLON.NodeEditor.SharedUIComponents.GraphNode, visitedNodes?: Set<BABYLON.NodeEditor.SharedUIComponents.GraphNode> | undefined, visitedLinks?: Set<BABYLON.NodeEditor.SharedUIComponents.NodeLink> | undefined) => void;
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export class TypeLedger {
+        static PortDataBuilder: (port: BABYLON.NodeEditor.SharedUIComponents.NodePort, nodeContainer: BABYLON.NodeEditor.SharedUIComponents.INodeContainer) => BABYLON.NodeEditor.SharedUIComponents.IPortData;
+        static NodeDataBuilder: (data: any, nodeContainer: BABYLON.NodeEditor.SharedUIComponents.INodeContainer) => BABYLON.NodeEditor.SharedUIComponents.INodeData;
+    }
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export type FramePortData = {
+        frame: BABYLON.NodeEditor.SharedUIComponents.GraphFrame;
+        port: FrameNodePort;
+    };
+
+
+
 }
 declare module BABYLON.NodeEditor {