babylonjs-node-editor 5.0.0-rc.9 → 5.0.0

package/babylon.nodeEditor.module.d.ts

@@ -1798,7 +1798,8 @@ export {};
 }
 declare module "babylonjs-node-editor/sharedComponents/matrixLineComponent" {
 import * as React from "react";
-import { Vector3, Matrix, Vector4 } from "babylonjs/Maths/math.vector";
+import { Vector3, Vector4 } from "babylonjs/Maths/math.vector";
+import { Matrix } from "babylonjs/Maths/math.vector";
 import { Observable } from "babylonjs/Misc/observable";
 import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
 import { GlobalState } from "babylonjs-node-editor/globalState";
@@ -2290,6 +2291,7 @@ export interface ICheckBoxLineComponentProps {
         enabled: IconDefinition;
         disabled: IconDefinition;
     };
+    large?: boolean;
 }
 export class CheckBoxLineComponent extends React.Component<ICheckBoxLineComponentProps, {
     isSelected: boolean;
@@ -2501,12 +2503,12 @@ interface IFloatLineComponentProps {
     icon?: string;
     iconLabel?: string;
     defaultValue?: number;
-    unit?: string;
-    onUnitClicked?: () => void;
-    unitLocked?: boolean;
+    arrows?: boolean;
+    unit?: React.ReactNode;
 }
 export class FloatLineComponent extends React.Component<IFloatLineComponentProps, {
     value: string;
+    dragging: boolean;
 }> {
     private _localChange;
     private _store;
@@ -2515,11 +2517,14 @@ export class FloatLineComponent extends React.Component<IFloatLineComponentProps
     getValueString(value: any): string;
     shouldComponentUpdate(nextProps: IFloatLineComponentProps, nextState: {
         value: string;
+        dragging: boolean;
     }): boolean;
     raiseOnPropertyChanged(newValue: number, previousValue: number): void;
     updateValue(valueString: string): void;
     lock(): void;
     unlock(): void;
+    incrementValue(amount: number): void;
+    onKeyDown(event: React.KeyboardEvent): void;
     render(): JSX.Element;
 }
 export {};
@@ -2623,6 +2628,7 @@ export class InputArrowsComponent extends React.Component<IInputArrowsComponentP
     private _arrowsRef;
     private _drag;
     private _releaseListener;
+    private _lockChangeListener;
     render(): JSX.Element;
 }
 export {};
@@ -2808,6 +2814,7 @@ interface ISliderLineComponentProps {
     icon?: string;
     iconLabel?: string;
     lockObject?: LockObject;
+    unit?: React.ReactNode;
 }
 export class SliderLineComponent extends React.Component<ISliderLineComponentProps, {
     value: number;
@@ -2844,7 +2851,7 @@ import * as React from "react";
 import { Observable } from "babylonjs/Misc/observable";
 import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
 import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
-interface ITextInputLineComponentProps {
+export interface ITextInputLineComponentProps {
     label?: string;
     lockObject?: LockObject;
     target?: any;
@@ -2857,9 +2864,6 @@ interface ITextInputLineComponentProps {
     noUnderline?: boolean;
     numbersOnly?: boolean;
     delayInput?: boolean;
-    unit?: string;
-    onUnitClicked?: (unit: string) => void;
-    unitLocked?: boolean;
     arrows?: boolean;
     arrowsIncrement?: (amount: number) => void;
     step?: number;
@@ -2868,6 +2872,7 @@ interface ITextInputLineComponentProps {
     min?: number;
     max?: number;
     placeholder?: string;
+    unit?: React.ReactNode;
 }
 export class TextInputLineComponent extends React.Component<ITextInputLineComponentProps, {
     value: string;
@@ -2881,12 +2886,12 @@ export class TextInputLineComponent extends React.Component<ITextInputLineCompon
         dragging: boolean;
     }): boolean;
     raiseOnPropertyChanged(newValue: string, previousValue: string): void;
+    getCurrentNumericValue(value: string): number;
     updateValue(value: string): void;
     incrementValue(amount: number): void;
     onKeyDown(event: React.KeyboardEvent): void;
     render(): JSX.Element;
 }
-export {};
 
 }
 declare module "shared-ui-components/lines/textLineComponent" {
@@ -2912,6 +2917,17 @@ export class TextLineComponent extends React.Component<ITextLineComponentProps>
 }
 export {};
 
+}
+declare module "shared-ui-components/lines/unitButton" {
+/// <reference types="react" />
+interface IUnitButtonProps {
+    unit: string;
+    locked?: boolean;
+    onClick?: (unit: string) => void;
+}
+export function UnitButton(props: IUnitButtonProps): JSX.Element;
+export {};
+
 }
 declare module "shared-ui-components/lines/valueLineComponent" {
 import * as React from "react";
@@ -3388,8 +3404,8 @@ declare module "babylonjs-node-editor" {
 
 
 declare module BABYLON.NodeEditor {
-        export class BlockTools {
-        static GetBlockFromString(data: string, scene: BABYLON.Scene, nodeMaterial: BABYLON.NodeMaterial): BABYLON.ElbowBlock | BABYLON.TwirlBlock | BABYLON.VoronoiNoiseBlock | BABYLON.ScreenSpaceBlock | BABYLON.CloudBlock | BABYLON.MatrixBuilderBlock | BABYLON.DesaturateBlock | BABYLON.RefractBlock | BABYLON.ReflectBlock | BABYLON.DerivativeBlock | BABYLON.Rotate2dBlock | BABYLON.NormalBlendBlock | BABYLON.WorleyNoise3DBlock | BABYLON.SimplexPerlin3DBlock | BABYLON.BonesBlock | BABYLON.InstancesBlock | BABYLON.MorphTargetsBlock | BABYLON.DiscardBlock | BABYLON.ImageProcessingBlock | BABYLON.ColorMergerBlock | BABYLON.VectorMergerBlock | BABYLON.ColorSplitterBlock | BABYLON.VectorSplitterBlock | BABYLON.TextureBlock | BABYLON.ReflectionTextureBlock | BABYLON.LightBlock | BABYLON.FogBlock | BABYLON.VertexOutputBlock | BABYLON.FragmentOutputBlock | BABYLON.AddBlock | BABYLON.ClampBlock | BABYLON.ScaleBlock | BABYLON.CrossBlock | BABYLON.DotBlock | BABYLON.PowBlock | BABYLON.MultiplyBlock | BABYLON.TransformBlock | BABYLON.TrigonometryBlock | BABYLON.RemapBlock | BABYLON.NormalizeBlock | BABYLON.FresnelBlock | BABYLON.LerpBlock | BABYLON.NLerpBlock | BABYLON.DivideBlock | BABYLON.SubtractBlock | BABYLON.ModBlock | BABYLON.StepBlock | BABYLON.SmoothStepBlock | BABYLON.OneMinusBlock | BABYLON.ReciprocalBlock | BABYLON.ViewDirectionBlock | BABYLON.LightInformationBlock | BABYLON.MaxBlock | BABYLON.MinBlock | BABYLON.LengthBlock | BABYLON.DistanceBlock | BABYLON.NegateBlock | BABYLON.PerturbNormalBlock | BABYLON.RandomNumberBlock | BABYLON.ReplaceColorBlock | BABYLON.PosterizeBlock | BABYLON.ArcTan2Block | BABYLON.GradientBlock | BABYLON.FrontFacingBlock | BABYLON.WaveBlock | BABYLON.InputBlock | BABYLON.PBRMetallicRoughnessBlock | BABYLON.SheenBlock | BABYLON.AnisotropyBlock | BABYLON.ReflectionBlock | BABYLON.ClearCoatBlock | BABYLON.RefractionBlock | BABYLON.SubSurfaceBlock | BABYLON.CurrentScreenBlock | BABYLON.ParticleTextureBlock | BABYLON.ParticleRampGradientBlock | BABYLON.ParticleBlendMultiplyBlock | BABYLON.FragCoordBlock | BABYLON.ScreenSizeBlock | BABYLON.SceneDepthBlock | BABYLON.ConditionalBlock | BABYLON.ImageSourceBlock | BABYLON.ClipPlanesBlock | null;
+    export class BlockTools {
+        static GetBlockFromString(data: string, scene: Scene, nodeMaterial: NodeMaterial): BABYLON.ElbowBlock | BABYLON.TwirlBlock | BABYLON.VoronoiNoiseBlock | BABYLON.ScreenSpaceBlock | BABYLON.CloudBlock | BABYLON.MatrixBuilderBlock | BABYLON.DesaturateBlock | BABYLON.RefractBlock | BABYLON.ReflectBlock | BABYLON.DerivativeBlock | BABYLON.Rotate2dBlock | BABYLON.NormalBlendBlock | BABYLON.WorleyNoise3DBlock | BABYLON.SimplexPerlin3DBlock | BABYLON.BonesBlock | BABYLON.InstancesBlock | BABYLON.MorphTargetsBlock | BABYLON.DiscardBlock | BABYLON.ImageProcessingBlock | BABYLON.ColorMergerBlock | BABYLON.VectorMergerBlock | BABYLON.ColorSplitterBlock | BABYLON.VectorSplitterBlock | BABYLON.TextureBlock | BABYLON.ReflectionTextureBlock | BABYLON.LightBlock | BABYLON.FogBlock | BABYLON.VertexOutputBlock | BABYLON.FragmentOutputBlock | BABYLON.AddBlock | BABYLON.ClampBlock | BABYLON.ScaleBlock | BABYLON.CrossBlock | BABYLON.DotBlock | BABYLON.PowBlock | BABYLON.MultiplyBlock | BABYLON.TransformBlock | BABYLON.TrigonometryBlock | BABYLON.RemapBlock | BABYLON.NormalizeBlock | BABYLON.FresnelBlock | BABYLON.LerpBlock | BABYLON.NLerpBlock | BABYLON.DivideBlock | BABYLON.SubtractBlock | BABYLON.ModBlock | BABYLON.StepBlock | BABYLON.SmoothStepBlock | BABYLON.OneMinusBlock | BABYLON.ReciprocalBlock | BABYLON.ViewDirectionBlock | BABYLON.LightInformationBlock | BABYLON.MaxBlock | BABYLON.MinBlock | BABYLON.LengthBlock | BABYLON.DistanceBlock | BABYLON.NegateBlock | BABYLON.PerturbNormalBlock | BABYLON.RandomNumberBlock | BABYLON.ReplaceColorBlock | BABYLON.PosterizeBlock | BABYLON.ArcTan2Block | BABYLON.GradientBlock | BABYLON.FrontFacingBlock | BABYLON.WaveBlock | BABYLON.InputBlock | BABYLON.PBRMetallicRoughnessBlock | BABYLON.SheenBlock | BABYLON.AnisotropyBlock | BABYLON.ReflectionBlock | BABYLON.ClearCoatBlock | BABYLON.RefractionBlock | BABYLON.SubSurfaceBlock | BABYLON.CurrentScreenBlock | BABYLON.ParticleTextureBlock | BABYLON.ParticleRampGradientBlock | BABYLON.ParticleBlendMultiplyBlock | BABYLON.FragCoordBlock | BABYLON.ScreenSizeBlock | BABYLON.SceneDepthBlock | BABYLON.ConditionalBlock | BABYLON.ImageSourceBlock | BABYLON.ClipPlanesBlock | null;
         static GetColorFromConnectionNodeType(type: BABYLON.NodeMaterialBlockConnectionPointTypes): string;
         static GetConnectionNodeTypeFromString(type: string): BABYLON.NodeMaterialBlockConnectionPointTypes.Float | BABYLON.NodeMaterialBlockConnectionPointTypes.Vector2 | BABYLON.NodeMaterialBlockConnectionPointTypes.Vector3 | BABYLON.NodeMaterialBlockConnectionPointTypes.Vector4 | BABYLON.NodeMaterialBlockConnectionPointTypes.Color3 | BABYLON.NodeMaterialBlockConnectionPointTypes.Color4 | BABYLON.NodeMaterialBlockConnectionPointTypes.Matrix | BABYLON.NodeMaterialBlockConnectionPointTypes.AutoDetect;
         static GetStringFromConnectionNodeType(type: BABYLON.NodeMaterialBlockConnectionPointTypes): "" | "Float" | "Vector2" | "Vector3" | "Vector4" | "Matrix" | "Color3" | "Color4";
@@ -3527,19 +3543,19 @@ declare module BABYLON.NodeEditor {
 
     interface IInputsPropertyTabComponentProps {
         globalState: GlobalState;
-        inputs: BABYLON.InputBlock[];
+        inputs: InputBlock[];
     }
     export class InputsPropertyTabComponent extends React.Component<IInputsPropertyTabComponentProps> {
         constructor(props: IInputsPropertyTabComponentProps);
-        processInputBlockUpdate(ib: BABYLON.InputBlock): void;
-        renderInputBlock(block: BABYLON.InputBlock): JSX.Element | null;
+        processInputBlockUpdate(ib: InputBlock): void;
+        renderInputBlock(block: InputBlock): JSX.Element | null;
         render(): JSX.Element;
     }
 
 
     interface IColor3PropertyTabComponentProps {
         globalState: GlobalState;
-        inputBlock: BABYLON.InputBlock;
+        inputBlock: InputBlock;
     }
     export class Color3PropertyTabComponent extends React.Component<IColor3PropertyTabComponentProps> {
         render(): JSX.Element;
@@ -3548,7 +3564,7 @@ declare module BABYLON.NodeEditor {
 
     interface IColor4PropertyTabComponentProps {
         globalState: GlobalState;
-        inputBlock: BABYLON.InputBlock;
+        inputBlock: InputBlock;
     }
     export class Color4PropertyTabComponent extends React.Component<IColor4PropertyTabComponentProps> {
         render(): JSX.Element;
@@ -3557,7 +3573,7 @@ declare module BABYLON.NodeEditor {
 
     interface IFloatPropertyTabComponentProps {
         globalState: GlobalState;
-        inputBlock: BABYLON.InputBlock;
+        inputBlock: InputBlock;
     }
     export class FloatPropertyTabComponent extends React.Component<IFloatPropertyTabComponentProps> {
         render(): JSX.Element;
@@ -3566,7 +3582,7 @@ declare module BABYLON.NodeEditor {
 
     interface IMatrixPropertyTabComponentProps {
         globalState: GlobalState;
-        inputBlock: BABYLON.InputBlock;
+        inputBlock: InputBlock;
     }
     export class MatrixPropertyTabComponent extends React.Component<IMatrixPropertyTabComponentProps> {
         render(): JSX.Element;
@@ -3575,7 +3591,7 @@ declare module BABYLON.NodeEditor {
 
     interface IVector2PropertyTabComponentProps {
         globalState: GlobalState;
-        inputBlock: BABYLON.InputBlock;
+        inputBlock: InputBlock;
     }
     export class Vector2PropertyTabComponent extends React.Component<IVector2PropertyTabComponentProps> {
         render(): JSX.Element;
@@ -3584,7 +3600,7 @@ declare module BABYLON.NodeEditor {
 
     interface IVector3PropertyTabComponentProps {
         globalState: GlobalState;
-        inputBlock: BABYLON.InputBlock;
+        inputBlock: InputBlock;
     }
     export class Vector3PropertyTabComponent extends React.Component<IVector3PropertyTabComponentProps> {
         render(): JSX.Element;
@@ -3593,7 +3609,7 @@ declare module BABYLON.NodeEditor {
 
     interface IVector4PropertyTabComponentProps {
         globalState: GlobalState;
-        inputBlock: BABYLON.InputBlock;
+        inputBlock: InputBlock;
     }
     export class Vector4PropertyTabComponent extends React.Component<IVector4PropertyTabComponentProps> {
         render(): JSX.Element;
@@ -3604,10 +3620,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: Nullable<GraphNode>;
+        currentFrame: Nullable<GraphFrame>;
+        currentFrameNodePort: Nullable<FrameNodePort>;
+        currentNodePort: Nullable<NodePort>;
         uploadInProgress: boolean;
     }
     export class PropertyTabComponent extends React.Component<IPropertyTabComponentProps, IPropertyTabComponentState> {
@@ -3616,8 +3632,8 @@ declare module BABYLON.NodeEditor {
         constructor(props: IPropertyTabComponentProps);
         componentDidMount(): void;
         componentWillUnmount(): void;
-        processInputBlockUpdate(ib: BABYLON.InputBlock): void;
-        renderInputBlock(block: BABYLON.InputBlock): JSX.Element | null;
+        processInputBlockUpdate(ib: InputBlock): void;
+        renderInputBlock(block: InputBlock): JSX.Element | null;
         load(file: File): void;
         loadFrame(file: File): void;
         save(): void;
@@ -3632,16 +3648,16 @@ declare module BABYLON.NodeEditor {
     export class ClampDisplayManager implements IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
+        getHeaderText(block: NodeMaterialBlock): string;
         getBackgroundColor(): string;
-        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
     }
 
 
     export class ConditionalDisplayManager implements IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
+        getHeaderText(block: NodeMaterialBlock): string;
         getBackgroundColor(): string;
         updatePreviewContent(): void;
     }
@@ -3650,36 +3666,36 @@ declare module BABYLON.NodeEditor {
     export class DiscardDisplayManager implements IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
+        getHeaderText(block: NodeMaterialBlock): string;
         getBackgroundColor(): string;
-        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        updatePreviewContent(block: 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;
+        getHeaderClass(block: NodeMaterialBlock): string;
+        shouldDisplayPortLabels(block: NodeMaterialBlock): boolean;
+        updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        getBackgroundColor(block: NodeMaterialBlock): string;
+        getHeaderText(block: NodeMaterialBlock): string;
     }
 
 
     export class ElbowDisplayManager implements IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
-        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
-        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        getHeaderText(block: NodeMaterialBlock): string;
+        getBackgroundColor(block: NodeMaterialBlock): string;
+        updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
     }
 
 
     export class GradientDisplayManager implements IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
-        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
-        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        getHeaderText(block: NodeMaterialBlock): string;
+        getBackgroundColor(block: NodeMaterialBlock): string;
+        updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
     }
 
 
@@ -3688,47 +3704,47 @@ declare module BABYLON.NodeEditor {
         private _previewImage;
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
+        getHeaderText(block: NodeMaterialBlock): string;
         getBackgroundColor(): string;
-        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
     }
 
 
     export class InputDisplayManager implements IDisplayManager {
-        getHeaderClass(block: BABYLON.NodeMaterialBlock): "" | "constant" | "inspector";
+        getHeaderClass(block: NodeMaterialBlock): "" | "constant" | "inspector";
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
+        getHeaderText(block: NodeMaterialBlock): string;
         static GetBaseType(type: BABYLON.NodeMaterialBlockConnectionPointTypes): string;
-        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
-        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        getBackgroundColor(block: NodeMaterialBlock): string;
+        updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
     }
 
 
     export class OutputDisplayManager implements IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
+        getHeaderText(block: NodeMaterialBlock): string;
         getBackgroundColor(): string;
-        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
     }
 
 
     export class PBRDisplayManager implements IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
+        getHeaderText(block: NodeMaterialBlock): string;
         getBackgroundColor(): string;
-        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
     }
 
 
     export class RemapDisplayManager implements IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
+        getHeaderText(block: NodeMaterialBlock): string;
         getBackgroundColor(): string;
         private _extractInputValue;
-        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
     }
 
 
@@ -3737,18 +3753,18 @@ declare module BABYLON.NodeEditor {
         private _previewImage;
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
-        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
-        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        getHeaderText(block: NodeMaterialBlock): string;
+        getBackgroundColor(block: NodeMaterialBlock): string;
+        updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
     }
 
 
     export class TrigonometryDisplayManager implements IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
+        getHeaderText(block: NodeMaterialBlock): string;
         getBackgroundColor(): string;
-        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
     }
 
 
@@ -3760,7 +3776,7 @@ declare module BABYLON.NodeEditor {
 
 
     export class FrameNodePort extends NodePort {
-        connectionPoint: BABYLON.NodeMaterialConnectionPoint;
+        connectionPoint: NodeMaterialConnectionPoint;
         node: GraphNode;
         private _parentFrameId;
         private _isInput;
@@ -3773,14 +3789,14 @@ declare module BABYLON.NodeEditor {
         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;
+        constructor(portContainer: HTMLElement, connectionPoint: NodeMaterialConnectionPoint, node: GraphNode, globalState: GlobalState, isInput: boolean, framePortId: number, parentFrameId: number);
+        static CreateFrameNodePortElement(connectionPoint: NodeMaterialConnectionPoint, node: GraphNode, root: HTMLElement, displayManager: Nullable<IDisplayManager>, globalState: GlobalState, isInput: boolean, framePortId: number, parentFrameId: number): FrameNodePort;
     }
 
 
     export interface IGraphCanvasComponentProps {
         globalState: GlobalState;
-        onEmitNewBlock: (block: BABYLON.NodeMaterialBlock) => GraphNode;
+        onEmitNewBlock: (block: NodeMaterialBlock) => GraphNode;
     }
     export type FramePortData = {
         frame: GraphFrame;
@@ -3836,9 +3852,9 @@ declare module BABYLON.NodeEditor {
         get y(): number;
         set y(value: number);
         get selectedNodes(): GraphNode[];
-        get selectedLink(): BABYLON.Nullable<NodeLink>;
+        get selectedLink(): Nullable<NodeLink>;
         get selectedFrames(): GraphFrame[];
-        get selectedPort(): BABYLON.Nullable<NodePort>;
+        get selectedPort(): Nullable<NodePort>;
         get canvasContainer(): HTMLDivElement;
         get hostCanvas(): HTMLDivElement;
         get svgCanvas(): HTMLElement;
@@ -3850,11 +3866,11 @@ declare module BABYLON.NodeEditor {
         getGridPositionCeil(position: number): number;
         updateTransform(): void;
         onKeyUp(): void;
-        findNodeFromBlock(block: BABYLON.NodeMaterialBlock): GraphNode;
+        findNodeFromBlock(block: NodeMaterialBlock): GraphNode;
         reset(): void;
-        connectPorts(pointA: BABYLON.NodeMaterialConnectionPoint, pointB: BABYLON.NodeMaterialConnectionPoint): void;
+        connectPorts(pointA: NodeMaterialConnectionPoint, pointB: NodeMaterialConnectionPoint): void;
         removeLink(link: NodeLink): void;
-        appendBlock(block: BABYLON.NodeMaterialBlock): GraphNode;
+        appendBlock(block: NodeMaterialBlock): GraphNode;
         distributeGraph(): void;
         componentDidMount(): void;
         onMove(evt: React.PointerEvent): void;
@@ -3863,7 +3879,7 @@ declare module BABYLON.NodeEditor {
         onWheel(evt: React.WheelEvent): void;
         zoomToFit(): void;
         processCandidatePort(): void;
-        connectNodes(nodeA: GraphNode, pointA: BABYLON.NodeMaterialConnectionPoint, nodeB: GraphNode, pointB: BABYLON.NodeMaterialConnectionPoint): void;
+        connectNodes(nodeA: GraphNode, pointA: NodeMaterialConnectionPoint, nodeB: GraphNode, pointB: NodeMaterialConnectionPoint): void;
         processEditorData(editorData: IEditorData): void;
         addFrame(frameData: IFrameData): void;
         render(): JSX.Element;
@@ -3949,7 +3965,7 @@ declare module BABYLON.NodeEditor {
         set height(value: number);
         get comments(): string;
         set comments(comments: string);
-        constructor(candidate: BABYLON.Nullable<HTMLDivElement>, canvas: GraphCanvasComponent, doNotCaptureNodes?: boolean);
+        constructor(candidate: Nullable<HTMLDivElement>, canvas: GraphCanvasComponent, doNotCaptureNodes?: boolean);
         refresh(): void;
         addNode(node: GraphNode): void;
         removeNode(node: GraphNode): void;
@@ -4020,7 +4036,7 @@ declare module BABYLON.NodeEditor {
 
     /// <reference types="react" />
     export class GraphNode {
-        block: BABYLON.NodeMaterialBlock;
+        block: NodeMaterialBlock;
         private _visual;
         private _headerContainer;
         private _promotionWarning;
@@ -4069,10 +4085,10 @@ declare module BABYLON.NodeEditor {
         get enclosingFrameId(): number;
         set enclosingFrameId(value: number);
         set isSelected(value: boolean);
-        constructor(block: BABYLON.NodeMaterialBlock, globalState: GlobalState);
+        constructor(block: NodeMaterialBlock, globalState: GlobalState);
         isOverlappingFrame(frame: GraphFrame): boolean;
-        getPortForConnectionPoint(point: BABYLON.NodeMaterialConnectionPoint): NodePort | null;
-        getLinksForConnectionPoint(point: BABYLON.NodeMaterialConnectionPoint): NodeLink[];
+        getPortForConnectionPoint(point: NodeMaterialConnectionPoint): NodePort | null;
+        getLinksForConnectionPoint(point: NodeMaterialConnectionPoint): NodeLink[];
         private _refreshFrames;
         _refreshLinks(): void;
         refresh(): void;
@@ -4080,7 +4096,7 @@ declare module BABYLON.NodeEditor {
         cleanAccumulation(useCeil?: boolean): void;
         private _onUp;
         private _onMove;
-        renderProperties(): BABYLON.Nullable<JSX.Element>;
+        renderProperties(): Nullable<JSX.Element>;
         appendVisual(root: HTMLDivElement, owner: GraphCanvasComponent): void;
         dispose(): void;
     }
@@ -4111,16 +4127,16 @@ declare module BABYLON.NodeEditor {
 
 
     export class NodePort {
-        connectionPoint: BABYLON.NodeMaterialConnectionPoint;
+        connectionPoint: 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 _onCandidateLinkMovedObserver: Nullable<Observer<Nullable<Vector2>>>;
+        protected _onSelectionChangedObserver: Nullable<Observer<Nullable<ISelectionChangedOptions>>>;
         protected _exposedOnFrame: boolean;
-        delegatedPort: BABYLON.Nullable<FrameNodePort>;
+        delegatedPort: Nullable<FrameNodePort>;
         get element(): HTMLDivElement;
         get portName(): string;
         set portName(newName: string);
@@ -4132,9 +4148,9 @@ declare module BABYLON.NodeEditor {
         set exposedPortPosition(value: number);
         private _isConnectedToNodeOutsideOfFrame;
         refresh(): void;
-        constructor(portContainer: HTMLElement, connectionPoint: BABYLON.NodeMaterialConnectionPoint, node: GraphNode, globalState: GlobalState);
+        constructor(portContainer: HTMLElement, connectionPoint: NodeMaterialConnectionPoint, node: GraphNode, globalState: GlobalState);
         dispose(): void;
-        static CreatePortElement(connectionPoint: BABYLON.NodeMaterialConnectionPoint, node: GraphNode, root: HTMLElement, displayManager: BABYLON.Nullable<IDisplayManager>, globalState: GlobalState): NodePort;
+        static CreatePortElement(connectionPoint: NodeMaterialConnectionPoint, node: GraphNode, root: HTMLElement, displayManager: Nullable<IDisplayManager>, globalState: GlobalState): NodePort;
     }
 
 
@@ -4193,7 +4209,7 @@ declare module BABYLON.NodeEditor {
             rebuild?: boolean;
             update?: boolean;
             activatePreviewCommand?: boolean;
-            callback?: (scene: BABYLON.Scene) => void;
+            callback?: (scene: Scene) => void;
         }): void;
         render(): JSX.Element;
     }
@@ -4215,7 +4231,7 @@ declare module BABYLON.NodeEditor {
 
     interface IGradientStepComponentProps {
         globalState: GlobalState;
-        step: BABYLON.GradientBlockColorStep;
+        step: GradientBlockColorStep;
         lineIndex: number;
         onDelete: () => void;
         onUpdateStep: () => void;
@@ -4236,7 +4252,7 @@ declare module BABYLON.NodeEditor {
     export class ImageSourcePropertyTabComponent extends React.Component<IPropertyComponentProps, {
         isEmbedded: boolean;
     }> {
-        get imageSourceBlock(): BABYLON.ImageSourceBlock;
+        get imageSourceBlock(): ImageSourceBlock;
         constructor(props: IPropertyComponentProps);
         UNSAFE_componentWillUpdate(nextProps: IPropertyComponentProps, nextState: {
             isEmbedded: boolean;
@@ -4292,12 +4308,12 @@ declare module BABYLON.NodeEditor {
 
     export interface IPropertyComponentProps {
         globalState: GlobalState;
-        block: BABYLON.NodeMaterialBlock;
+        block: NodeMaterialBlock;
     }
 
 
     type ReflectionTexture = BABYLON.ReflectionTextureBlock | BABYLON.ReflectionBlock | BABYLON.RefractionBlock;
-    type AnyTexture = BABYLON.TextureBlock | ReflectionTexture | BABYLON.CurrentScreenBlock | BABYLON.ParticleTextureBlock;
+    type AnyTexture = TextureBlock | ReflectionTexture | BABYLON.CurrentScreenBlock | BABYLON.ParticleTextureBlock;
     export class TexturePropertyTabComponent extends React.Component<IPropertyComponentProps, {
         isEmbedded: boolean;
         loadAsCubeTexture: boolean;
@@ -4349,20 +4365,20 @@ declare module BABYLON.NodeEditor {
 
 
     export class ISelectionChangedOptions {
-        selection: BABYLON.Nullable<GraphNode | NodeLink | GraphFrame | NodePort | FramePortData>;
+        selection: Nullable<GraphNode | NodeLink | GraphFrame | NodePort | FramePortData>;
         forceKeepSelection?: boolean;
     }
     export class GlobalState {
-        nodeMaterial: BABYLON.NodeMaterial;
+        nodeMaterial: NodeMaterial;
         hostElement: HTMLElement;
         hostDocument: HTMLDocument;
         hostWindow: Window;
         onNewNodeCreatedObservable: BABYLON.Observable<GraphNode>;
-        onSelectionChangedObservable: BABYLON.Observable<BABYLON.Nullable<ISelectionChangedOptions>>;
+        onSelectionChangedObservable: BABYLON.Observable<Nullable<ISelectionChangedOptions>>;
         onRebuildRequiredObservable: BABYLON.Observable<boolean>;
         onBuiltObservable: BABYLON.Observable<void>;
         onResetRequiredObservable: BABYLON.Observable<void>;
-        onUpdateRequiredObservable: BABYLON.Observable<BABYLON.Nullable<BABYLON.NodeMaterialBlock>>;
+        onUpdateRequiredObservable: BABYLON.Observable<Nullable<NodeMaterialBlock>>;
         onZoomToFitRequiredObservable: BABYLON.Observable<void>;
         onReOrganizedRequiredObservable: BABYLON.Observable<void>;
         onLogRequiredObservable: BABYLON.Observable<LogEntry>;
@@ -4374,10 +4390,10 @@ declare module BABYLON.NodeEditor {
         onBackFaceCullingChanged: BABYLON.Observable<void>;
         onDepthPrePassChanged: BABYLON.Observable<void>;
         onAnimationCommandActivated: BABYLON.Observable<void>;
-        onCandidateLinkMoved: BABYLON.Observable<BABYLON.Nullable<BABYLON.Vector2>>;
+        onCandidateLinkMoved: BABYLON.Observable<Nullable<Vector2>>;
         onSelectionBoxMoved: BABYLON.Observable<ClientRect | DOMRect>;
         onFrameCreatedObservable: BABYLON.Observable<GraphFrame>;
-        onCandidatePortSelectedObservable: BABYLON.Observable<BABYLON.Nullable<NodePort | FrameNodePort>>;
+        onCandidatePortSelectedObservable: BABYLON.Observable<Nullable<NodePort | FrameNodePort>>;
         onImportFrameObservable: BABYLON.Observable<any>;
         onGraphNodeRemovalObservable: BABYLON.Observable<GraphNode>;
         onPopupClosedObservable: BABYLON.Observable<void>;
@@ -4387,7 +4403,7 @@ declare module BABYLON.NodeEditor {
             targetY: number;
             needRepositioning?: boolean | undefined;
         }>;
-        onGetNodeFromBlock: (block: BABYLON.NodeMaterialBlock) => GraphNode;
+        onGetNodeFromBlock: (block: NodeMaterialBlock) => GraphNode;
         onGridSizeChanged: BABYLON.Observable<void>;
         onExposePortOnFrameObservable: BABYLON.Observable<GraphNode>;
         previewType: PreviewType;
@@ -4403,7 +4419,7 @@ declare module BABYLON.NodeEditor {
         directionalLight0: boolean;
         directionalLight1: boolean;
         controlCamera: boolean;
-        storeEditorData: (serializationObject: any, frame?: BABYLON.Nullable<GraphFrame>) => void;
+        storeEditorData: (serializationObject: any, frame?: Nullable<GraphFrame>) => void;
         _mode: BABYLON.NodeMaterialModes;
         /** Gets the mode */
         get mode(): BABYLON.NodeMaterialModes;
@@ -4423,7 +4439,7 @@ declare module BABYLON.NodeEditor {
     interface IGraphEditorState {
         showPreviewPopUp: boolean;
     }
-    interface IInternalPreviewAreaOptions extends BABYLON.IInspectorOptions {
+    interface IInternalPreviewAreaOptions extends IInspectorOptions {
         popup: boolean;
         original: boolean;
         explorerWidth?: string;
@@ -4454,7 +4470,7 @@ declare module BABYLON.NodeEditor {
          * @param block
          * @param recursion
          */
-        createNodeFromObject(block: BABYLON.NodeMaterialBlock, recursion?: boolean): GraphNode;
+        createNodeFromObject(block: NodeMaterialBlock, recursion?: boolean): GraphNode;
         addValueNode(type: string): GraphNode;
         componentDidMount(): void;
         componentWillUnmount(): void;
@@ -4467,7 +4483,7 @@ declare module BABYLON.NodeEditor {
         loadGraph(): void;
         showWaitScreen(): void;
         hideWaitScreen(): void;
-        reOrganize(editorData?: BABYLON.Nullable<IEditorData>, isImportingAFrame?: boolean): void;
+        reOrganize(editorData?: Nullable<IEditorData>, isImportingAFrame?: boolean): void;
         onPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
         onPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
         resizeColumns(evt: React.PointerEvent<HTMLDivElement>, forLeft?: boolean): void;
@@ -4479,8 +4495,8 @@ declare module BABYLON.NodeEditor {
         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;
+        createPreviewMeshControlHost: (options: IInternalPreviewAreaOptions, parentControl: Nullable<HTMLElement>) => void;
+        createPreviewHost: (options: IInternalPreviewAreaOptions, parentControl: Nullable<HTMLElement>) => void;
         fixPopUpStyles: (document: Document) => void;
         render(): JSX.Element;
     }
@@ -4492,13 +4508,13 @@ declare module BABYLON.NodeEditor {
      * Interface used to specify creation options for the node editor
      */
     export interface INodeEditorOptions {
-        nodeMaterial: BABYLON.NodeMaterial;
+        nodeMaterial: NodeMaterial;
         hostElement?: HTMLElement;
         customSave?: {
             label: string;
             action: (data: string) => Promise<void>;
         };
-        customLoadObservable?: BABYLON.Observable<any>;
+        customLoadObservable?: Observable<any>;
     }
     /**
      * Class used to create a node editor
@@ -4550,10 +4566,10 @@ 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: NodeMaterial, globalState: GlobalState, frame?: Nullable<GraphFrame>): void;
+        static Serialize(material: NodeMaterial, globalState: GlobalState, frame?: Nullable<GraphFrame>): string;
         static Deserialize(serializationObject: any, globalState: GlobalState): void;
-        static AddFrameToMaterial(serializationObject: any, globalState: GlobalState, currentMaterial: BABYLON.NodeMaterial): void;
+        static AddFrameToMaterial(serializationObject: any, globalState: GlobalState, currentMaterial: NodeMaterial): void;
     }
 
 
@@ -4575,7 +4591,7 @@ declare module BABYLON.NodeEditor {
         isSelected?: () => boolean;
         onSelect?: (value: boolean) => void;
         onValueChanged?: () => void;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
         disabled?: boolean;
     }
     export class CheckBoxLineComponent extends React.Component<ICheckBoxLineComponentProps, {
@@ -4599,7 +4615,7 @@ declare module BABYLON.NodeEditor {
         label: string;
         target: any;
         propertyName: string;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
         onChange?: () => void;
         globalState: GlobalState;
     }
@@ -4622,7 +4638,7 @@ declare module BABYLON.NodeEditor {
         label: string;
         target: any;
         propertyName: string;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
         onChange?: () => void;
         globalState: GlobalState;
     }
@@ -4641,13 +4657,13 @@ declare module BABYLON.NodeEditor {
 
 
     export interface IColorPickerComponentProps {
-        value: BABYLON.Color4 | BABYLON.Color3;
+        value: Color4 | Color3;
         onColorChanged: (newOne: string) => void;
         globalState: GlobalState;
     }
     interface IColorPickerComponentState {
         pickerEnabled: boolean;
-        color: BABYLON.Color3 | BABYLON.Color4;
+        color: Color3 | Color4;
         hex: string;
     }
     export class ColorPickerLineComponent extends React.Component<IColorPickerComponentProps, IColorPickerComponentState> {
@@ -4707,7 +4723,7 @@ declare module BABYLON.NodeEditor {
         propertyName: string;
         onChange?: (newValue: number) => void;
         isInteger?: boolean;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
         additionalClass?: string;
         step?: string;
         digits?: number;
@@ -4777,7 +4793,7 @@ declare module BABYLON.NodeEditor {
         step?: number;
         onChange?: (newValue: BABYLON.Matrix) => void;
         onModeChange?: (mode: number) => void;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
         mode?: number;
         globalState: GlobalState;
     }
@@ -4793,9 +4809,9 @@ declare module BABYLON.NodeEditor {
             mode: number;
             angle: number;
         }): boolean;
-        raiseOnPropertyChanged(previousValue: BABYLON.Vector3): void;
+        raiseOnPropertyChanged(previousValue: Vector3): void;
         updateMatrix(): void;
-        updateRow(value: BABYLON.Vector4, row: number): void;
+        updateRow(value: Vector4, row: number): void;
         updateBasedOnMode(value: number): void;
         render(): JSX.Element;
     }
@@ -4841,10 +4857,10 @@ declare module BABYLON.NodeEditor {
         target: any;
         className?: string;
         propertyName?: string;
-        options: BABYLON.IInspectableOptions[];
+        options: IInspectableOptions[];
         noDirectUpdate?: boolean;
         onSelect?: (value: number | string) => void;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
         valuesAreStrings?: boolean;
         defaultIfNull?: number;
         getSelection?: (target: any) => number;
@@ -4890,7 +4906,7 @@ declare module BABYLON.NodeEditor {
         useEuler?: boolean;
         onChange?: (value: number) => void;
         onInput?: (value: number) => void;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
         decimalCount?: number;
         globalState: GlobalState;
     }
@@ -4918,7 +4934,7 @@ declare module BABYLON.NodeEditor {
         multilines?: boolean;
         onChange?: (value: string) => void;
         validator?: (value: string) => boolean;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
     }
     export class TextInputLineComponent extends React.Component<ITextInputLineComponentProps, {
         value: string;
@@ -4952,7 +4968,7 @@ declare module BABYLON.NodeEditor {
 
 
     interface ITextureLineComponentProps {
-        texture: BABYLON.BaseTexture;
+        texture: BaseTexture;
         width: number;
         height: number;
         globalState?: any;
@@ -4972,7 +4988,7 @@ declare module BABYLON.NodeEditor {
         componentDidMount(): void;
         componentDidUpdate(): void;
         updatePreview(): void;
-        static UpdatePreview(previewCanvas: HTMLCanvasElement, texture: BABYLON.BaseTexture, width: number, options: ITextureLineComponentState, onReady?: () => void, globalState?: any): Promise<void>;
+        static UpdatePreview(previewCanvas: HTMLCanvasElement, texture: BaseTexture, width: number, options: ITextureLineComponentState, onReady?: () => void, globalState?: any): Promise<void>;
         render(): JSX.Element;
     }
 
@@ -4982,13 +4998,13 @@ declare module BABYLON.NodeEditor {
         target: any;
         propertyName: string;
         step?: number;
-        onChange?: (newvalue: BABYLON.Vector2) => void;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onChange?: (newvalue: Vector2) => void;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
         globalState: GlobalState;
     }
     export class Vector2LineComponent extends React.Component<IVector2LineComponentProps, {
         isExpanded: boolean;
-        value: BABYLON.Vector2;
+        value: Vector2;
     }> {
         static defaultProps: {
             step: number;
@@ -4997,10 +5013,10 @@ declare module BABYLON.NodeEditor {
         constructor(props: IVector2LineComponentProps);
         shouldComponentUpdate(nextProps: IVector2LineComponentProps, nextState: {
             isExpanded: boolean;
-            value: BABYLON.Vector2;
+            value: Vector2;
         }): boolean;
         switchExpandState(): void;
-        raiseOnPropertyChanged(previousValue: BABYLON.Vector2): void;
+        raiseOnPropertyChanged(previousValue: Vector2): void;
         updateStateX(value: number): void;
         updateStateY(value: number): void;
         render(): JSX.Element;
@@ -5012,13 +5028,13 @@ declare module BABYLON.NodeEditor {
         target: any;
         propertyName: string;
         step?: number;
-        onChange?: (newvalue: BABYLON.Vector3) => void;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onChange?: (newvalue: Vector3) => void;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
         globalState: GlobalState;
     }
     export class Vector3LineComponent extends React.Component<IVector3LineComponentProps, {
         isExpanded: boolean;
-        value: BABYLON.Vector3;
+        value: Vector3;
     }> {
         static defaultProps: {
             step: number;
@@ -5027,10 +5043,10 @@ declare module BABYLON.NodeEditor {
         constructor(props: IVector3LineComponentProps);
         shouldComponentUpdate(nextProps: IVector3LineComponentProps, nextState: {
             isExpanded: boolean;
-            value: BABYLON.Vector3;
+            value: Vector3;
         }): boolean;
         switchExpandState(): void;
-        raiseOnPropertyChanged(previousValue: BABYLON.Vector3): void;
+        raiseOnPropertyChanged(previousValue: Vector3): void;
         updateVector3(): void;
         updateStateX(value: number): void;
         updateStateY(value: number): void;
@@ -5043,15 +5059,15 @@ declare module BABYLON.NodeEditor {
         label: string;
         target?: any;
         propertyName?: string;
-        value?: BABYLON.Vector4;
+        value?: Vector4;
         step?: number;
-        onChange?: (newvalue: BABYLON.Vector4) => void;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onChange?: (newvalue: Vector4) => void;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
         globalState: GlobalState;
     }
     export class Vector4LineComponent extends React.Component<IVector4LineComponentProps, {
         isExpanded: boolean;
-        value: BABYLON.Vector4;
+        value: Vector4;
     }> {
         static defaultProps: {
             step: number;
@@ -5060,10 +5076,10 @@ declare module BABYLON.NodeEditor {
         constructor(props: IVector4LineComponentProps);
         shouldComponentUpdate(nextProps: IVector4LineComponentProps, nextState: {
             isExpanded: boolean;
-            value: BABYLON.Vector4;
+            value: Vector4;
         }): boolean;
         switchExpandState(): void;
-        raiseOnPropertyChanged(previousValue: BABYLON.Vector4): void;
+        raiseOnPropertyChanged(previousValue: Vector4): void;
         updateVector4(): void;
         updateStateX(value: number): void;
         updateStateY(value: number): void;
@@ -5176,7 +5192,7 @@ declare module BABYLON.NodeEditor {
         isSelected?: () => boolean;
         onSelect?: (value: boolean) => void;
         onValueChanged?: () => void;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
         disabled?: boolean;
         icon?: string;
         iconLabel?: string;
@@ -5184,6 +5200,7 @@ declare module BABYLON.NodeEditor {
             enabled: IconDefinition;
             disabled: IconDefinition;
         };
+        large?: boolean;
     }
     export class CheckBoxLineComponent extends React.Component<ICheckBoxLineComponentProps, {
         isSelected: boolean;
@@ -5206,7 +5223,7 @@ declare module BABYLON.NodeEditor {
         label: string;
         target: any;
         propertyName: string;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
         isLinear?: boolean;
         icon?: string;
         lockObject?: LockObject;
@@ -5222,7 +5239,7 @@ declare module BABYLON.NodeEditor {
         label: string;
         target?: any;
         propertyName: string;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
         onChange?: () => void;
         isLinear?: boolean;
         icon?: string;
@@ -5238,7 +5255,7 @@ declare module BABYLON.NodeEditor {
         label: string;
         target?: any;
         propertyName: string;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
         onChange?: () => void;
         isLinear?: boolean;
         icon?: string;
@@ -5271,7 +5288,7 @@ declare module BABYLON.NodeEditor {
 
 
     export interface IColorPickerComponentProps {
-        value: BABYLON.Color4 | BABYLON.Color3;
+        value: Color4 | Color3;
         linearHint?: boolean;
         onColorChanged: (newOne: string) => void;
         icon?: string;
@@ -5280,7 +5297,7 @@ declare module BABYLON.NodeEditor {
     }
     interface IColorPickerComponentState {
         pickerEnabled: boolean;
-        color: BABYLON.Color3 | BABYLON.Color4;
+        color: Color3 | Color4;
         hex: string;
     }
     export class ColorPickerLineComponent extends React.Component<IColorPickerComponentProps, IColorPickerComponentState> {
@@ -5349,7 +5366,7 @@ declare module BABYLON.NodeEditor {
         lockObject?: LockObject;
         onChange?: (newValue: number) => void;
         isInteger?: boolean;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
         additionalClass?: string;
         step?: string;
         digits?: number;
@@ -5361,12 +5378,12 @@ declare module BABYLON.NodeEditor {
         icon?: string;
         iconLabel?: string;
         defaultValue?: number;
-        unit?: string;
-        onUnitClicked?: () => void;
-        unitLocked?: boolean;
+        arrows?: boolean;
+        unit?: React.ReactNode;
     }
     export class FloatLineComponent extends React.Component<IFloatLineComponentProps, {
         value: string;
+        dragging: boolean;
     }> {
         private _localChange;
         private _store;
@@ -5375,11 +5392,14 @@ declare module BABYLON.NodeEditor {
         getValueString(value: any): string;
         shouldComponentUpdate(nextProps: IFloatLineComponentProps, nextState: {
             value: string;
+            dragging: boolean;
         }): boolean;
         raiseOnPropertyChanged(newValue: number, previousValue: number): void;
         updateValue(valueString: string): void;
         lock(): void;
         unlock(): void;
+        incrementValue(amount: number): void;
+        onKeyDown(event: React.KeyboardEvent): void;
         render(): JSX.Element;
     }
 
@@ -5392,7 +5412,7 @@ declare module BABYLON.NodeEditor {
         onChange?: (newValue: number) => void;
         isInteger?: boolean;
         replaySourceReplacement?: string;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
         additionalClass?: string;
         step?: string;
         digits?: number;
@@ -5466,6 +5486,7 @@ declare module BABYLON.NodeEditor {
         private _arrowsRef;
         private _drag;
         private _releaseListener;
+        private _lockChangeListener;
         render(): JSX.Element;
     }
 
@@ -5551,11 +5572,11 @@ declare module BABYLON.NodeEditor {
         label: string;
         target: any;
         propertyName: string;
-        options: BABYLON.IInspectableOptions[];
+        options: IInspectableOptions[];
         noDirectUpdate?: boolean;
         onSelect?: (value: number) => void;
         extractValue?: () => number;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
         allowNullValue?: boolean;
         icon?: string;
         iconLabel?: string;
@@ -5583,7 +5604,7 @@ declare module BABYLON.NodeEditor {
 
 
     interface IRadioButtonLineComponentProps {
-        onSelectionChangedObservable: BABYLON.Observable<RadioButtonLineComponent>;
+        onSelectionChangedObservable: Observable<RadioButtonLineComponent>;
         label: string;
         isSelected: () => boolean;
         onSelect: () => void;
@@ -5613,12 +5634,13 @@ declare module BABYLON.NodeEditor {
         useEuler?: boolean;
         onChange?: (value: number) => void;
         onInput?: (value: number) => void;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
         decimalCount?: number;
         margin?: boolean;
         icon?: string;
         iconLabel?: string;
         lockObject?: LockObject;
+        unit?: React.ReactNode;
     }
     export class SliderLineComponent extends React.Component<ISliderLineComponentProps, {
         value: number;
@@ -5643,25 +5665,22 @@ declare module BABYLON.NodeEditor {
      * @param getProperty
      * @returns a proxy object that can be passed as a target into the input
      */
-    export function makeTargetsProxy<Type>(targets: Type[], onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>, getProperty?: (target: Type, property: keyof Type) => any): any;
+    export function makeTargetsProxy<Type>(targets: Type[], onPropertyChangedObservable?: Observable<PropertyChangedEvent>, getProperty?: (target: Type, property: keyof Type) => any): any;
 
 
-    interface ITextInputLineComponentProps {
+    export interface ITextInputLineComponentProps {
         label?: string;
         lockObject?: LockObject;
         target?: any;
         propertyName?: string;
         value?: string;
         onChange?: (value: string) => void;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
         icon?: string;
         iconLabel?: string;
         noUnderline?: boolean;
         numbersOnly?: boolean;
         delayInput?: boolean;
-        unit?: string;
-        onUnitClicked?: (unit: string) => void;
-        unitLocked?: boolean;
         arrows?: boolean;
         arrowsIncrement?: (amount: number) => void;
         step?: number;
@@ -5670,6 +5689,7 @@ declare module BABYLON.NodeEditor {
         min?: number;
         max?: number;
         placeholder?: string;
+        unit?: React.ReactNode;
     }
     export class TextInputLineComponent extends React.Component<ITextInputLineComponentProps, {
         value: string;
@@ -5683,6 +5703,7 @@ declare module BABYLON.NodeEditor {
             dragging: boolean;
         }): boolean;
         raiseOnPropertyChanged(newValue: string, previousValue: string): void;
+        getCurrentNumericValue(value: string): number;
         updateValue(value: string): void;
         incrementValue(amount: number): void;
         onKeyDown(event: React.KeyboardEvent): void;
@@ -5711,6 +5732,15 @@ declare module BABYLON.NodeEditor {
     }
 
 
+    /// <reference types="react" />
+    interface IUnitButtonProps {
+        unit: string;
+        locked?: boolean;
+        onClick?: (unit: string) => void;
+    }
+    export function UnitButton(props: IUnitButtonProps): JSX.Element;
+
+
     interface IValueLineComponentProps {
         label: string;
         value: number;
@@ -5731,14 +5761,14 @@ declare module BABYLON.NodeEditor {
         target: any;
         propertyName: string;
         step?: number;
-        onChange?: (newvalue: BABYLON.Vector2) => void;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onChange?: (newvalue: Vector2) => void;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
         icon?: string;
         iconLabel?: string;
     }
     export class Vector2LineComponent extends React.Component<IVector2LineComponentProps, {
         isExpanded: boolean;
-        value: BABYLON.Vector2;
+        value: Vector2;
     }> {
         static defaultProps: {
             step: number;
@@ -5747,10 +5777,10 @@ declare module BABYLON.NodeEditor {
         constructor(props: IVector2LineComponentProps);
         shouldComponentUpdate(nextProps: IVector2LineComponentProps, nextState: {
             isExpanded: boolean;
-            value: BABYLON.Vector2;
+            value: Vector2;
         }): boolean;
         switchExpandState(): void;
-        raiseOnPropertyChanged(previousValue: BABYLON.Vector2): void;
+        raiseOnPropertyChanged(previousValue: Vector2): void;
         updateStateX(value: number): void;
         updateStateY(value: number): void;
         render(): JSX.Element;
@@ -5762,16 +5792,16 @@ declare module BABYLON.NodeEditor {
         target: any;
         propertyName: string;
         step?: number;
-        onChange?: (newvalue: BABYLON.Vector3) => void;
+        onChange?: (newvalue: Vector3) => void;
         useEuler?: boolean;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
         noSlider?: boolean;
         icon?: string;
         iconLabel?: string;
     }
     export class Vector3LineComponent extends React.Component<IVector3LineComponentProps, {
         isExpanded: boolean;
-        value: BABYLON.Vector3;
+        value: Vector3;
     }> {
         static defaultProps: {
             step: number;
@@ -5781,10 +5811,10 @@ declare module BABYLON.NodeEditor {
         getCurrentValue(): any;
         shouldComponentUpdate(nextProps: IVector3LineComponentProps, nextState: {
             isExpanded: boolean;
-            value: BABYLON.Vector3;
+            value: Vector3;
         }): boolean;
         switchExpandState(): void;
-        raiseOnPropertyChanged(previousValue: BABYLON.Vector3): void;
+        raiseOnPropertyChanged(previousValue: Vector3): void;
         updateVector3(): void;
         updateStateX(value: number): void;
         updateStateY(value: number): void;
@@ -5798,15 +5828,15 @@ declare module BABYLON.NodeEditor {
         target: any;
         propertyName: string;
         step?: number;
-        onChange?: (newvalue: BABYLON.Vector4) => void;
+        onChange?: (newvalue: Vector4) => void;
         useEuler?: boolean;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
         icon?: string;
         iconLabel?: string;
     }
     export class Vector4LineComponent extends React.Component<IVector4LineComponentProps, {
         isExpanded: boolean;
-        value: BABYLON.Vector4;
+        value: Vector4;
     }> {
         static defaultProps: {
             step: number;
@@ -5816,10 +5846,10 @@ declare module BABYLON.NodeEditor {
         getCurrentValue(): any;
         shouldComponentUpdate(nextProps: IVector4LineComponentProps, nextState: {
             isExpanded: boolean;
-            value: BABYLON.Vector4;
+            value: Vector4;
         }): boolean;
         switchExpandState(): void;
-        raiseOnPropertyChanged(previousValue: BABYLON.Vector4): void;
+        raiseOnPropertyChanged(previousValue: Vector4): void;
         updateVector4(): void;
         updateStateX(value: number): void;
         updateStateY(value: number): void;
@@ -5852,9 +5882,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface ICheckboxPropertyGridComponentProps {
-        checkbox: BABYLON.GUI.Checkbox;
+        checkbox: Checkbox;
         lockObject: LockObject;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
     }
     export class CheckboxPropertyGridComponent extends React.Component<ICheckboxPropertyGridComponentProps> {
         constructor(props: ICheckboxPropertyGridComponentProps);
@@ -5863,9 +5893,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface IColorPickerPropertyGridComponentProps {
-        colorPicker: BABYLON.GUI.ColorPicker;
+        colorPicker: ColorPicker;
         lockObject: LockObject;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
     }
     export class ColorPickerPropertyGridComponent extends React.Component<IColorPickerPropertyGridComponentProps> {
         constructor(props: IColorPickerPropertyGridComponentProps);
@@ -5877,7 +5907,7 @@ declare module BABYLON.NodeEditor {
         controls?: BABYLON.GUI.Control[];
         control?: BABYLON.GUI.Control;
         lockObject: LockObject;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
     }
     export class CommonControlPropertyGridComponent extends React.Component<ICommonControlPropertyGridComponentProps> {
         constructor(props: ICommonControlPropertyGridComponentProps);
@@ -5887,9 +5917,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface IControlPropertyGridComponentProps {
-        control: BABYLON.GUI.Control;
+        control: Control;
         lockObject: LockObject;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
     }
     export class ControlPropertyGridComponent extends React.Component<IControlPropertyGridComponentProps> {
         constructor(props: IControlPropertyGridComponentProps);
@@ -5898,9 +5928,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface IEllipsePropertyGridComponentProps {
-        ellipse: BABYLON.GUI.Ellipse;
+        ellipse: Ellipse;
         lockObject: LockObject;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
     }
     export class EllipsePropertyGridComponent extends React.Component<IEllipsePropertyGridComponentProps> {
         constructor(props: IEllipsePropertyGridComponentProps);
@@ -5909,9 +5939,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface IGridPropertyGridComponentProps {
-        grid: BABYLON.GUI.Grid;
+        grid: Grid;
         lockObject: LockObject;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
     }
     export class GridPropertyGridComponent extends React.Component<IGridPropertyGridComponentProps> {
         constructor(props: IGridPropertyGridComponentProps);
@@ -5922,9 +5952,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface IImageBasedSliderPropertyGridComponentProps {
-        imageBasedSlider: BABYLON.GUI.ImageBasedSlider;
+        imageBasedSlider: ImageBasedSlider;
         lockObject: LockObject;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
     }
     export class ImageBasedSliderPropertyGridComponent extends React.Component<IImageBasedSliderPropertyGridComponentProps> {
         constructor(props: IImageBasedSliderPropertyGridComponentProps);
@@ -5935,7 +5965,7 @@ declare module BABYLON.NodeEditor {
     interface IImagePropertyGridComponentProps {
         image: BABYLON.GUI.Image;
         lockObject: LockObject;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
     }
     export class ImagePropertyGridComponent extends React.Component<IImagePropertyGridComponentProps> {
         constructor(props: IImagePropertyGridComponentProps);
@@ -5944,9 +5974,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface IInputTextPropertyGridComponentProps {
-        inputText: BABYLON.GUI.InputText;
+        inputText: InputText;
         lockObject: LockObject;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
     }
     export class InputTextPropertyGridComponent extends React.Component<IInputTextPropertyGridComponentProps> {
         constructor(props: IInputTextPropertyGridComponentProps);
@@ -5955,9 +5985,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface ILinePropertyGridComponentProps {
-        line: BABYLON.GUI.Line;
+        line: Line;
         lockObject: LockObject;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
     }
     export class LinePropertyGridComponent extends React.Component<ILinePropertyGridComponentProps> {
         constructor(props: ILinePropertyGridComponentProps);
@@ -5967,9 +5997,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface IRadioButtonPropertyGridComponentProps {
-        radioButtons: BABYLON.GUI.RadioButton[];
+        radioButtons: RadioButton[];
         lockObject: LockObject;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
     }
     export class RadioButtonPropertyGridComponent extends React.Component<IRadioButtonPropertyGridComponentProps> {
         constructor(props: IRadioButtonPropertyGridComponentProps);
@@ -5978,9 +6008,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface IRectanglePropertyGridComponentProps {
-        rectangle: BABYLON.GUI.Rectangle;
+        rectangle: Rectangle;
         lockObject: LockObject;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
     }
     export class RectanglePropertyGridComponent extends React.Component<IRectanglePropertyGridComponentProps> {
         constructor(props: IRectanglePropertyGridComponentProps);
@@ -5989,9 +6019,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface IScrollViewerPropertyGridComponentProps {
-        scrollViewer: BABYLON.GUI.ScrollViewer;
+        scrollViewer: ScrollViewer;
         lockObject: LockObject;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
     }
     export class ScrollViewerPropertyGridComponent extends React.Component<IScrollViewerPropertyGridComponentProps> {
         constructor(props: IScrollViewerPropertyGridComponentProps);
@@ -6000,9 +6030,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface ISliderPropertyGridComponentProps {
-        slider: BABYLON.GUI.Slider;
+        slider: Slider;
         lockObject: LockObject;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
     }
     export class SliderPropertyGridComponent extends React.Component<ISliderPropertyGridComponentProps> {
         constructor(props: ISliderPropertyGridComponentProps);
@@ -6011,9 +6041,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface IStackPanelPropertyGridComponentProps {
-        stackPanel: BABYLON.GUI.StackPanel;
+        stackPanel: StackPanel;
         lockObject: LockObject;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
     }
     export class StackPanelPropertyGridComponent extends React.Component<IStackPanelPropertyGridComponentProps> {
         constructor(props: IStackPanelPropertyGridComponentProps);
@@ -6022,9 +6052,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface ITextBlockPropertyGridComponentProps {
-        textBlock: BABYLON.GUI.TextBlock;
+        textBlock: TextBlock;
         lockObject: LockObject;
-        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
     }
     export class TextBlockPropertyGridComponent extends React.Component<ITextBlockPropertyGridComponentProps> {
         constructor(props: ITextBlockPropertyGridComponentProps);