babylonjs-gui 5.0.0 → 5.0.1

package/babylon.gui.d.ts

@@ -3,7 +3,7 @@ declare module BABYLON.GUI {
     /**
      * This class can be used to get instrumentation data from a AdvancedDynamicTexture object
      */
-    export class AdvancedDynamicTextureInstrumentation implements IDisposable {
+    export class AdvancedDynamicTextureInstrumentation implements BABYLON.IDisposable {
         /**
          * Define the instrumented AdvancedDynamicTexture.
          */
@@ -91,7 +91,7 @@ declare module BABYLON.GUI {
         /** @hidden */
         _shouldBlockPointer: boolean;
         /** @hidden */
-        _layerToDispose: Nullable<BABYLON.Layer>;
+        _layerToDispose: BABYLON.Nullable<BABYLON.Layer>;
         /** @hidden */
         _linkedControls: Control[];
         private _isFullscreen;
@@ -194,7 +194,7 @@ declare module BABYLON.GUI {
         /**
          * Gets the underlying layer used to render the texture when in fullscreen mode
          */
-        get layer(): Nullable<BABYLON.Layer>;
+        get layer(): BABYLON.Nullable<BABYLON.Layer>;
         /**
          * Gets the root container control
          */
@@ -223,13 +223,13 @@ declare module BABYLON.GUI {
          * @param name defines the name to search for
          * @return the first control found or null
          */
-        getControlByName(name: string): Nullable<Control>;
+        getControlByName(name: string): BABYLON.Nullable<Control>;
         private _getControlByKey;
         /**
          * Gets or sets the current focused control
          */
-        get focusedControl(): Nullable<IFocusableControl>;
-        set focusedControl(control: Nullable<IFocusableControl>);
+        get focusedControl(): BABYLON.Nullable<IFocusableControl>;
+        set focusedControl(control: BABYLON.Nullable<IFocusableControl>);
         /**
          * Gets or sets a boolean indicating if the texture must be rendered in background or foreground when in fullscreen mode
          */
@@ -257,7 +257,7 @@ declare module BABYLON.GUI {
          * @param samplingMode defines the texture sampling mode (Texture.NEAREST_SAMPLINGMODE by default)
          * @param invertY defines if the texture needs to be inverted on the y axis during loading (true by default)
          */
-        constructor(name: string, width?: number, height?: number, scene?: Nullable<Scene>, generateMipMaps?: boolean, samplingMode?: number, invertY?: boolean);
+        constructor(name: string, width?: number, height?: number, scene?: BABYLON.Nullable<BABYLON.Scene>, generateMipMaps?: boolean, samplingMode?: number, invertY?: boolean);
         /**
          * Get the current class name of the texture useful for serialization or dynamic coding.
          * @returns "AdvancedDynamicTexture"
@@ -327,14 +327,14 @@ declare module BABYLON.GUI {
          * @param worldMatrix defines the world matrix to use
          * @returns the projected position
          */
-        getProjectedPosition(position: BABYLON.Vector3, worldMatrix: Matrix): BABYLON.Vector2;
+        getProjectedPosition(position: BABYLON.Vector3, worldMatrix: BABYLON.Matrix): BABYLON.Vector2;
         /**
          * Get screen coordinates for a vector3
          * @param position defines the position to project
          * @param worldMatrix defines the world matrix to use
          * @returns the projected position with Z
          */
-        getProjectedPositionWithZ(position: BABYLON.Vector3, worldMatrix: Matrix): BABYLON.Vector3;
+        getProjectedPositionWithZ(position: BABYLON.Vector3, worldMatrix: BABYLON.Matrix): BABYLON.Vector3;
         private _checkUpdate;
         private _clearMeasure;
         private _render;
@@ -394,7 +394,7 @@ declare module BABYLON.GUI {
          * @param mesh defines the mesh to attach to
          * @param supportPointerMove defines a boolean indicating if pointer move events must be catched as well
          */
-        attachToMesh(mesh: AbstractMesh, supportPointerMove?: boolean): void;
+        attachToMesh(mesh: BABYLON.AbstractMesh, supportPointerMove?: boolean): void;
         /**
          * Move the focus to a specific control
          * @param control defines the control which will receive the focus
@@ -447,7 +447,7 @@ declare module BABYLON.GUI {
          * @param materialSetupCallback defines a custom way of creating and setting up the material on the mesh
          * @returns a new AdvancedDynamicTexture
          */
-        static CreateForMesh(mesh: AbstractMesh, width?: number, height?: number, supportPointerMove?: boolean, onlyAlphaTesting?: boolean, invertY?: boolean, materialSetupCallback?: (mesh: AbstractMesh, uniqueId: string, texture: AdvancedDynamicTexture, onlyAlphaTesting: boolean) => void): AdvancedDynamicTexture;
+        static CreateForMesh(mesh: BABYLON.AbstractMesh, width?: number, height?: number, supportPointerMove?: boolean, onlyAlphaTesting?: boolean, invertY?: boolean, materialSetupCallback?: (mesh: BABYLON.AbstractMesh, uniqueId: string, texture: AdvancedDynamicTexture, onlyAlphaTesting: boolean) => void): AdvancedDynamicTexture;
         private static _CreateMaterial;
         /**
          * Creates a new AdvancedDynamicTexture in projected mode (ie. attached to a mesh) BUT do not create a new material for the mesh. You will be responsible for connecting the texture
@@ -458,7 +458,7 @@ declare module BABYLON.GUI {
          * @param invertY defines if the texture needs to be inverted on the y axis during loading (true by default)
          * @returns a new AdvancedDynamicTexture
          */
-        static CreateForMeshTexture(mesh: AbstractMesh, width?: number, height?: number, supportPointerMove?: boolean, invertY?: boolean): AdvancedDynamicTexture;
+        static CreateForMeshTexture(mesh: BABYLON.AbstractMesh, width?: number, height?: number, supportPointerMove?: boolean, invertY?: boolean): AdvancedDynamicTexture;
         /**
          * Creates a new AdvancedDynamicTexture in fullscreen mode.
          * In this mode the texture will rely on a layer for its rendering.
@@ -472,7 +472,7 @@ declare module BABYLON.GUI {
          * @param adaptiveScaling defines whether to automatically scale root to match hardwarescaling (false by default)
          * @returns a new AdvancedDynamicTexture
          */
-        static CreateFullscreenUI(name: string, foreground?: boolean, scene?: Nullable<Scene>, sampling?: number, adaptiveScaling?: boolean): AdvancedDynamicTexture;
+        static CreateFullscreenUI(name: string, foreground?: boolean, scene?: BABYLON.Nullable<BABYLON.Scene>, sampling?: number, adaptiveScaling?: boolean): AdvancedDynamicTexture;
         /**
          * Scales the texture
          * @param ratio the scale factor to apply to both width and height
@@ -516,12 +516,12 @@ declare module BABYLON.GUI {
         /**
          * Returns the image part of the button (if any)
          */
-        get image(): Nullable<Image>;
+        get image(): BABYLON.Nullable<Image>;
         private _textBlock;
         /**
          * Returns the image part of the button (if any)
          */
-        get textBlock(): Nullable<TextBlock>;
+        get textBlock(): BABYLON.Nullable<TextBlock>;
         /**
          * Creates a new Button
          * @param name defines the name of the button
@@ -539,20 +539,20 @@ declare module BABYLON.GUI {
          * @param deltaY
          * @hidden
          */
-        _processPicking(x: number, y: number, pi: PointerInfoBase, type: number, pointerId: number, buttonIndex: number, deltaX?: number, deltaY?: number): boolean;
+        _processPicking(x: number, y: number, pi: BABYLON.PointerInfoBase, type: number, pointerId: number, buttonIndex: number, deltaX?: number, deltaY?: number): boolean;
         /**
          * @param target
          * @param pi
          * @hidden
          */
-        _onPointerEnter(target: Control, pi: PointerInfoBase): boolean;
+        _onPointerEnter(target: Control, pi: BABYLON.PointerInfoBase): boolean;
         /**
          * @param target
          * @param pi
          * @param force
          * @hidden
          */
-        _onPointerOut(target: Control, pi: PointerInfoBase, force?: boolean): void;
+        _onPointerOut(target: Control, pi: BABYLON.PointerInfoBase, force?: boolean): void;
         /**
          * @param target
          * @param coordinates
@@ -561,7 +561,7 @@ declare module BABYLON.GUI {
          * @param pi
          * @hidden
          */
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, pi: PointerInfoBase): boolean;
+        _onPointerDown(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, pi: BABYLON.PointerInfoBase): boolean;
         /**
          * @param target
          * @param coordinates
@@ -571,7 +571,7 @@ declare module BABYLON.GUI {
          * @param pi
          * @hidden
          */
-        _onPointerUp(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean, pi: PointerInfoBase): void;
+        _onPointerUp(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean, pi: BABYLON.PointerInfoBase): void;
         /**
          * Serializes the current button
          * @param serializationObject defines the JSON serialized object
@@ -651,7 +651,7 @@ declare module BABYLON.GUI {
          * @param context
          * @hidden
          */
-        _draw(context: ICanvasRenderingContext): void;
+        _draw(context: BABYLON.ICanvasRenderingContext): void;
         /**
          * @param target
          * @param coordinates
@@ -660,7 +660,7 @@ declare module BABYLON.GUI {
          * @param pi
          * @hidden
          */
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, pi: PointerInfoBase): boolean;
+        _onPointerDown(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, pi: BABYLON.PointerInfoBase): boolean;
         /**
          * Utility function to easily create a checkbox with a header
          * @param title defines the label to use for the header
@@ -729,14 +729,14 @@ declare module BABYLON.GUI {
          * @param context
          * @hidden
          */
-        _draw(context: ICanvasRenderingContext): void;
+        _draw(context: BABYLON.ICanvasRenderingContext): void;
         private _pointerIsDown;
         private _updateValueFromPointer;
         private _isPointOnSquare;
         private _isPointOnWheel;
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, pi: PointerInfoBase): boolean;
-        _onPointerMove(target: Control, coordinates: Vector2, pointerId: number, pi: PointerInfoBase): void;
-        _onPointerUp(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean, pi: PointerInfoBase): void;
+        _onPointerDown(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, pi: BABYLON.PointerInfoBase): boolean;
+        _onPointerMove(target: Control, coordinates: BABYLON.Vector2, pointerId: number, pi: BABYLON.PointerInfoBase): void;
+        _onPointerUp(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean, pi: BABYLON.PointerInfoBase): void;
         _onCanvasBlur(): void;
         /**
          * This function expands the color picker by creating a color picker dialog with manual
@@ -787,7 +787,7 @@ declare module BABYLON.GUI {
         /** @hidden */
         protected _renderToIntermediateTexture: boolean;
         /** @hidden */
-        protected _intermediateTexture: Nullable<BABYLON.DynamicTexture>;
+        protected _intermediateTexture: BABYLON.Nullable<BABYLON.DynamicTexture>;
         /** Gets or sets boolean indicating if children should be rendered to an intermediate texture rather than directly to host, useful for alpha blending */
         get renderToIntermediateTexture(): boolean;
         set renderToIntermediateTexture(value: boolean);
@@ -824,14 +824,14 @@ declare module BABYLON.GUI {
          * @param name defines the child name to look for
          * @returns the child control if found
          */
-        getChildByName(name: string): Nullable<Control>;
+        getChildByName(name: string): BABYLON.Nullable<Control>;
         /**
          * Gets a child using its type and its name
          * @param name defines the child name to look for
          * @param type defines the child type to look for
          * @returns the child control if found
          */
-        getChildByType(name: string, type: string): Nullable<Control>;
+        getChildByType(name: string, type: string): BABYLON.Nullable<Control>;
         /**
          * Search for a specific control in children
          * @param control defines the control to look for
@@ -843,7 +843,7 @@ declare module BABYLON.GUI {
          * @param control defines the control to add
          * @returns the current container
          */
-        addControl(control: Nullable<Control>): Container;
+        addControl(control: BABYLON.Nullable<Control>): Container;
         /**
          * Removes all controls from the current container
          * @returns the current container
@@ -876,7 +876,7 @@ declare module BABYLON.GUI {
          * @param context
          * @hidden
          */
-        protected _localDraw(context: ICanvasRenderingContext): void;
+        protected _localDraw(context: BABYLON.ICanvasRenderingContext): void;
         /**
          * @param host
          * @hidden
@@ -889,20 +889,20 @@ declare module BABYLON.GUI {
          * @param context
          * @hidden
          */
-        protected _processMeasures(parentMeasure: Measure, context: ICanvasRenderingContext): void;
+        protected _processMeasures(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
         /**
          * @param parentMeasure
          * @param context
          * @hidden
          */
-        _layout(parentMeasure: Measure, context: ICanvasRenderingContext): boolean;
+        _layout(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): boolean;
         protected _postMeasure(): void;
         /**
          * @param context
          * @param invalidatedRectangle
          * @hidden
          */
-        _draw(context: ICanvasRenderingContext, invalidatedRectangle?: Measure): void;
+        _draw(context: BABYLON.ICanvasRenderingContext, invalidatedRectangle?: Measure): void;
         getDescendantsToRef(results: Control[], directDescendantsOnly?: boolean, predicate?: (control: Control) => boolean): void;
         /**
          * @param x
@@ -915,13 +915,13 @@ declare module BABYLON.GUI {
          * @param deltaY
          * @hidden
          */
-        _processPicking(x: number, y: number, pi: Nullable<PointerInfoBase>, type: number, pointerId: number, buttonIndex: number, deltaX?: number, deltaY?: number): boolean;
+        _processPicking(x: number, y: number, pi: BABYLON.Nullable<BABYLON.PointerInfoBase>, type: number, pointerId: number, buttonIndex: number, deltaX?: number, deltaY?: number): boolean;
         /**
          * @param parentMeasure
          * @param context
          * @hidden
          */
-        protected _additionalProcessing(parentMeasure: Measure, context: ICanvasRenderingContext): void;
+        protected _additionalProcessing(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
         /**
          * Serializes the current control
          * @param serializationObject defined the JSON serialized object
@@ -955,7 +955,7 @@ declare module BABYLON.GUI {
         /** @hidden */
         _host: AdvancedDynamicTexture;
         /** Gets or sets the control parent */
-        parent: Nullable<Container>;
+        parent: BABYLON.Nullable<Container>;
         /** @hidden */
         _currentMeasure: Measure;
         /** @hidden */
@@ -1020,7 +1020,7 @@ declare module BABYLON.GUI {
         private _highlightColor;
         protected _highlightLineWidth: number;
         /** @hidden */
-        _linkedMesh: Nullable<TransformNode>;
+        _linkedMesh: BABYLON.Nullable<BABYLON.TransformNode>;
         private _fontSet;
         private _dummyVector2;
         private _downCount;
@@ -1271,8 +1271,8 @@ declare module BABYLON.GUI {
          * Gets or sets style
          * @see https://doc.babylonjs.com/how_to/gui#styles
          */
-        get style(): Nullable<Style>;
-        set style(value: Nullable<Style>);
+        get style(): BABYLON.Nullable<Style>;
+        set style(value: BABYLON.Nullable<Style>);
         /** @hidden */
         get _isFontSizeInPercentage(): boolean;
         /** Gets or sets font size in pixels */
@@ -1298,7 +1298,7 @@ declare module BABYLON.GUI {
         /**
          * Gets the current linked mesh (or null if none)
          */
-        get linkedMesh(): Nullable<TransformNode>;
+        get linkedMesh(): BABYLON.Nullable<BABYLON.TransformNode>;
         /**
          * Gets or sets a value indicating the padding should work like in CSS.
          * Basically, it will add the padding amount on each side of the parent control for its children.
@@ -1447,7 +1447,7 @@ declare module BABYLON.GUI {
          * @param className defines the required type
          * @returns the ascendant or null if not found
          */
-        getAscendantOfClass(className: string): Nullable<Control>;
+        getAscendantOfClass(className: string): BABYLON.Nullable<Control>;
         /**
          * Mark control element as dirty
          * @param force force non visible elements to be marked too
@@ -1489,7 +1489,7 @@ declare module BABYLON.GUI {
          * @param position defines the target position
          * @param scene defines the hosting scene
          */
-        moveToVector3(position: BABYLON.Vector3, scene: Scene): void;
+        moveToVector3(position: BABYLON.Vector3, scene: BABYLON.Scene): void;
         /**
          * Will store all controls that have this control as ascendant in a given array
          * @param results defines the array where to store the descendants
@@ -1509,7 +1509,7 @@ declare module BABYLON.GUI {
          * @param mesh defines the mesh to link with
          * @see https://doc.babylonjs.com/how_to/gui#tracking-positions
          */
-        linkWithMesh(mesh: Nullable<TransformNode>): void;
+        linkWithMesh(mesh: BABYLON.Nullable<BABYLON.TransformNode>): void;
         /**
          * Shorthand function to set the top, right, bottom, and left padding values on the control.
          * @param { string | number} paddingTop - The value of the top padding.
@@ -1552,7 +1552,7 @@ declare module BABYLON.GUI {
          * @param context
          * @hidden
          */
-        _intersectsRect(rect: Measure, context?: ICanvasRenderingContext): boolean;
+        _intersectsRect(rect: Measure, context?: BABYLON.ICanvasRenderingContext): boolean;
         /** @hidden */
         protected _computeAdditionnalOffsetX(): number;
         /** @hidden */
@@ -1575,34 +1575,34 @@ declare module BABYLON.GUI {
          * @param context
          * @hidden
          */
-        protected _transform(context?: ICanvasRenderingContext): void;
+        protected _transform(context?: BABYLON.ICanvasRenderingContext): void;
         /**
          * @param context
          * @hidden
          */
-        _renderHighlight(context: ICanvasRenderingContext): void;
+        _renderHighlight(context: BABYLON.ICanvasRenderingContext): void;
         /**
          * @param context
          * @hidden
          */
-        _renderHighlightSpecific(context: ICanvasRenderingContext): void;
+        _renderHighlightSpecific(context: BABYLON.ICanvasRenderingContext): void;
         /**
          * @param context
          * @hidden
          */
-        protected _applyStates(context: ICanvasRenderingContext): void;
+        protected _applyStates(context: BABYLON.ICanvasRenderingContext): void;
         /**
          * @param parentMeasure
          * @param context
          * @hidden
          */
-        _layout(parentMeasure: Measure, context: ICanvasRenderingContext): boolean;
+        _layout(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): boolean;
         /**
          * @param parentMeasure
          * @param context
          * @hidden
          */
-        protected _processMeasures(parentMeasure: Measure, context: ICanvasRenderingContext): void;
+        protected _processMeasures(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
         protected _evaluateClippingState(parentMeasure: Measure): void;
         /** @hidden */
         _measure(): void;
@@ -1611,24 +1611,24 @@ declare module BABYLON.GUI {
          * @param context
          * @hidden
          */
-        protected _computeAlignment(parentMeasure: Measure, context: ICanvasRenderingContext): void;
+        protected _computeAlignment(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
         /**
          * @param parentMeasure
          * @param context
          * @hidden
          */
-        protected _preMeasure(parentMeasure: Measure, context: ICanvasRenderingContext): void;
+        protected _preMeasure(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
         /**
          * @param parentMeasure
          * @param context
          * @hidden
          */
-        protected _additionalProcessing(parentMeasure: Measure, context: ICanvasRenderingContext): void;
+        protected _additionalProcessing(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
         /**
          * @param context
          * @hidden
          */
-        protected _clipForChildren(context: ICanvasRenderingContext): void;
+        protected _clipForChildren(context: BABYLON.ICanvasRenderingContext): void;
         private static _ClipMeasure;
         private _tmpMeasureA;
         private _clip;
@@ -1637,13 +1637,13 @@ declare module BABYLON.GUI {
          * @param invalidatedRectangle
          * @hidden
          */
-        _render(context: ICanvasRenderingContext, invalidatedRectangle?: Nullable<Measure>): boolean;
+        _render(context: BABYLON.ICanvasRenderingContext, invalidatedRectangle?: BABYLON.Nullable<Measure>): boolean;
         /**
          * @param context
          * @param invalidatedRectangle
          * @hidden
          */
-        _draw(context: ICanvasRenderingContext, invalidatedRectangle?: Nullable<Measure>): void;
+        _draw(context: BABYLON.ICanvasRenderingContext, invalidatedRectangle?: BABYLON.Nullable<Measure>): void;
         /**
          * Tests if a given coordinates belong to the current control
          * @param x defines x coordinate to test
@@ -1662,7 +1662,7 @@ declare module BABYLON.GUI {
          * @param deltaY
          * @hidden
          */
-        _processPicking(x: number, y: number, pi: Nullable<PointerInfoBase>, type: number, pointerId: number, buttonIndex: number, deltaX?: number, deltaY?: number): boolean;
+        _processPicking(x: number, y: number, pi: BABYLON.Nullable<BABYLON.PointerInfoBase>, type: number, pointerId: number, buttonIndex: number, deltaX?: number, deltaY?: number): boolean;
         /**
          * @param target
          * @param coordinates
@@ -1670,20 +1670,20 @@ declare module BABYLON.GUI {
          * @param pi
          * @hidden
          */
-        _onPointerMove(target: Control, coordinates: BABYLON.Vector2, pointerId: number, pi: Nullable<PointerInfoBase>): void;
+        _onPointerMove(target: Control, coordinates: BABYLON.Vector2, pointerId: number, pi: BABYLON.Nullable<BABYLON.PointerInfoBase>): void;
         /**
          * @param target
          * @param pi
          * @hidden
          */
-        _onPointerEnter(target: Control, pi: Nullable<PointerInfoBase>): boolean;
+        _onPointerEnter(target: Control, pi: BABYLON.Nullable<BABYLON.PointerInfoBase>): boolean;
         /**
          * @param target
          * @param pi
          * @param force
          * @hidden
          */
-        _onPointerOut(target: Control, pi: Nullable<PointerInfoBase>, force?: boolean): void;
+        _onPointerOut(target: Control, pi: BABYLON.Nullable<BABYLON.PointerInfoBase>, force?: boolean): void;
         /**
          * @param target
          * @param coordinates
@@ -1692,7 +1692,7 @@ declare module BABYLON.GUI {
          * @param pi
          * @hidden
          */
-        _onPointerDown(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, pi: Nullable<PointerInfoBase>): boolean;
+        _onPointerDown(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, pi: BABYLON.Nullable<BABYLON.PointerInfoBase>): boolean;
         /**
          * @param target
          * @param coordinates
@@ -1702,12 +1702,12 @@ declare module BABYLON.GUI {
          * @param pi
          * @hidden
          */
-        _onPointerUp(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean, pi?: Nullable<PointerInfoBase>): void;
+        _onPointerUp(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean, pi?: BABYLON.Nullable<BABYLON.PointerInfoBase>): void;
         /**
          * @param pointerId
          * @hidden
          */
-        _forcePointerUp(pointerId?: Nullable<number>): void;
+        _forcePointerUp(pointerId?: BABYLON.Nullable<number>): void;
         /**
          * @param deltaX
          * @param deltaY
@@ -1727,7 +1727,7 @@ declare module BABYLON.GUI {
          * @param deltaY
          * @hidden
          */
-        _processObservables(type: number, x: number, y: number, pi: Nullable<PointerInfoBase>, pointerId: number, buttonIndex: number, deltaX?: number, deltaY?: number): boolean;
+        _processObservables(type: number, x: number, y: number, pi: BABYLON.Nullable<BABYLON.PointerInfoBase>, pointerId: number, buttonIndex: number, deltaX?: number, deltaY?: number): boolean;
         private _prepareFont;
         /**
          * Serializes the current control
@@ -1789,7 +1789,7 @@ declare module BABYLON.GUI {
          * @param context
          * @hidden
          */
-        protected static drawEllipse(x: number, y: number, width: number, height: number, context: ICanvasRenderingContext): void;
+        protected static drawEllipse(x: number, y: number, width: number, height: number, context: BABYLON.ICanvasRenderingContext): void;
     }
 
 
@@ -1841,7 +1841,7 @@ declare module BABYLON.GUI {
          * @param name defines the control name
          */
         constructor(name?: string | undefined);
-        _draw(context: ICanvasRenderingContext): void;
+        _draw(context: BABYLON.ICanvasRenderingContext): void;
         protected _getTypeName(): string;
     }
 
@@ -1859,10 +1859,10 @@ declare module BABYLON.GUI {
          */
         constructor(name?: string | undefined);
         protected _getTypeName(): string;
-        protected _localDraw(context: ICanvasRenderingContext): void;
-        protected _additionalProcessing(parentMeasure: Measure, context: ICanvasRenderingContext): void;
-        protected _clipForChildren(context: ICanvasRenderingContext): void;
-        _renderHighlightSpecific(context: ICanvasRenderingContext): void;
+        protected _localDraw(context: BABYLON.ICanvasRenderingContext): void;
+        protected _additionalProcessing(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
+        protected _clipForChildren(context: BABYLON.ICanvasRenderingContext): void;
+        _renderHighlightSpecific(context: BABYLON.ICanvasRenderingContext): void;
     }
 
 
@@ -1873,7 +1873,7 @@ declare module BABYLON.GUI {
     export class FocusableButton extends Button implements IFocusableControl {
         name?: string | undefined;
         /** Highlight color when button is focused */
-        focusedColor: Nullable<string>;
+        focusedColor: BABYLON.Nullable<string>;
         private _isFocused;
         private _unfocusedColor;
         /** BABYLON.Observable raised when the control gets the focus */
@@ -1881,7 +1881,7 @@ declare module BABYLON.GUI {
         /** BABYLON.Observable raised when the control loses the focus */
         onBlurObservable: BABYLON.Observable<Button>;
         /** BABYLON.Observable raised when a key event was processed */
-        onKeyboardEventProcessedObservable: BABYLON.Observable<IKeyboardEvent>;
+        onKeyboardEventProcessedObservable: BABYLON.Observable<BABYLON.IKeyboardEvent>;
         constructor(name?: string | undefined);
         /** @hidden */
         onBlur(): void;
@@ -1891,7 +1891,7 @@ declare module BABYLON.GUI {
          * Function called to get the list of controls that should not steal the focus from this control
          * @returns an array of controls
          */
-        keepsFocusWith(): Nullable<Control[]>;
+        keepsFocusWith(): BABYLON.Nullable<Control[]>;
         /**
          * Function to focus a button programmatically
          */
@@ -1904,7 +1904,7 @@ declare module BABYLON.GUI {
          * Handles the keyboard event
          * @param evt Defines the KeyboardEvent
          */
-        processKeyboard(evt: IKeyboardEvent): void;
+        processKeyboard(evt: BABYLON.IKeyboardEvent): void;
         /**
          * @param target
          * @param coordinates
@@ -1913,7 +1913,7 @@ declare module BABYLON.GUI {
          * @param pi
          * @hidden
          */
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, pi: PointerInfoBase): boolean;
+        _onPointerDown(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, pi: BABYLON.PointerInfoBase): boolean;
         /** @hidden */
         displose(): void;
     }
@@ -1935,12 +1935,12 @@ declare module BABYLON.GUI {
          * Function called to let the control handle keyboard events
          * @param evt defines the current keyboard event
          */
-        processKeyboard(evt: IKeyboardEvent): void;
+        processKeyboard(evt: BABYLON.IKeyboardEvent): void;
         /**
          * Function called to get the list of controls that should not steal the focus from this control
          * @returns an array of controls
          */
-        keepsFocusWith(): Nullable<Control[]>;
+        keepsFocusWith(): BABYLON.Nullable<Control[]>;
         /**
          * Function to focus the control programmatically
          */
@@ -1982,13 +1982,13 @@ declare module BABYLON.GUI {
          * @param index defines the index of the row
          * @returns the row definition
          */
-        getRowDefinition(index: number): Nullable<ValueAndUnit>;
+        getRowDefinition(index: number): BABYLON.Nullable<ValueAndUnit>;
         /**
          * Gets the definition of a specific column
          * @param index defines the index of the column
          * @returns the column definition
          */
-        getColumnDefinition(index: number): Nullable<ValueAndUnit>;
+        getColumnDefinition(index: number): BABYLON.Nullable<ValueAndUnit>;
         /**
          * Adds a new row to the grid
          * @param height defines the height of the row (either in pixel or a value between 0 and 1)
@@ -2025,7 +2025,7 @@ declare module BABYLON.GUI {
          * @param column defines the column to check
          * @returns the list of controls
          */
-        getChildrenAt(row: number, column: number): Nullable<Array<Control>>;
+        getChildrenAt(row: number, column: number): BABYLON.Nullable<Array<Control>>;
         /**
          * Gets a string representing the child cell info (row x column)
          * @param child defines the control to get info from
@@ -2067,9 +2067,9 @@ declare module BABYLON.GUI {
         constructor(name?: string | undefined);
         protected _getTypeName(): string;
         protected _getGridDefinitions(definitionCallback: (lefts: number[], tops: number[], widths: number[], heights: number[]) => void): void;
-        protected _additionalProcessing(parentMeasure: Measure, context: ICanvasRenderingContext): void;
+        protected _additionalProcessing(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
         _flagDescendantsAsMatrixDirty(): void;
-        _renderHighlightSpecific(context: ICanvasRenderingContext): void;
+        _renderHighlightSpecific(context: BABYLON.ICanvasRenderingContext): void;
         /** Releases associated resources */
         dispose(): void;
         /**
@@ -2211,17 +2211,17 @@ declare module BABYLON.GUI {
         /**
          * Gets or sets the internal DOM image used to render the control
          */
-        set domImage(value: IImage);
-        get domImage(): IImage;
+        set domImage(value: BABYLON.IImage);
+        get domImage(): BABYLON.IImage;
         private _onImageLoaded;
         /**
          * Gets the image source url
          */
-        get source(): Nullable<string>;
+        get source(): BABYLON.Nullable<string>;
         /**
          * Gets or sets image source url
          */
-        set source(value: Nullable<string>);
+        set source(value: BABYLON.Nullable<string>);
         /**
          * Checks for svg document with icon id present
          * @param value
@@ -2257,7 +2257,7 @@ declare module BABYLON.GUI {
          * @param name defines the control name
          * @param url defines the image url
          */
-        constructor(name?: string | undefined, url?: Nullable<string>);
+        constructor(name?: string | undefined, url?: BABYLON.Nullable<string>);
         /**
          * Tests if a given coordinates belong to the current control
          * @param x defines x coordinate to test
@@ -2268,10 +2268,10 @@ declare module BABYLON.GUI {
         protected _getTypeName(): string;
         /** Force the control to synchronize with its content */
         synchronizeSizeWithContent(): void;
-        protected _processMeasures(parentMeasure: Measure, context: ICanvasRenderingContext): void;
+        protected _processMeasures(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
         private _prepareWorkingCanvasForOpaqueDetection;
         private _drawImage;
-        _draw(context: ICanvasRenderingContext): void;
+        _draw(context: BABYLON.ICanvasRenderingContext): void;
         private _renderNinePatch;
         dispose(): void;
         /** STRETCH_NONE */
@@ -2337,7 +2337,7 @@ declare module BABYLON.GUI {
         private _onClipboardObserver;
         private _onPointerDblTapObserver;
         /** @hidden */
-        _connectedVirtualKeyboard: Nullable<VirtualKeyboard>;
+        _connectedVirtualKeyboard: BABYLON.Nullable<VirtualKeyboard>;
         /** Gets or sets a string representing the message displayed on mobile when the control gets the focus */
         promptMessage: string;
         /** Force disable prompt on mobile device */
@@ -2359,7 +2359,7 @@ declare module BABYLON.GUI {
         /** BABYLON.Observable raised when paste event is triggered */
         onTextPasteObservable: BABYLON.Observable<InputText>;
         /** BABYLON.Observable raised when a key event was processed */
-        onKeyboardEventProcessedObservable: BABYLON.Observable<IKeyboardEvent>;
+        onKeyboardEventProcessedObservable: BABYLON.Observable<BABYLON.IKeyboardEvent>;
         /** Gets or sets the maximum width allowed by the control */
         get maxWidth(): string | number;
         /** Gets the maximum width allowed by the control in pixels */
@@ -2442,14 +2442,14 @@ declare module BABYLON.GUI {
          * Function called to get the list of controls that should not steal the focus from this control
          * @returns an array of controls
          */
-        keepsFocusWith(): Nullable<Control[]>;
+        keepsFocusWith(): BABYLON.Nullable<Control[]>;
         /**
          * @param keyCode
          * @param key
          * @param evt
          * @hidden
          */
-        processKey(keyCode: number, key?: string, evt?: IKeyboardEvent): void;
+        processKey(keyCode: number, key?: string, evt?: BABYLON.IKeyboardEvent): void;
         /**
          * @param offset
          * @hidden
@@ -2466,7 +2466,7 @@ declare module BABYLON.GUI {
          * Handles the keyboard event
          * @param evt Defines the KeyboardEvent
          */
-        processKeyboard(evt: IKeyboardEvent): void;
+        processKeyboard(evt: BABYLON.IKeyboardEvent): void;
         /**
          * @param ev
          * @hidden
@@ -2482,10 +2482,10 @@ declare module BABYLON.GUI {
          * @hidden
          */
         private _onPasteText;
-        _draw(context: ICanvasRenderingContext): void;
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, pi: PointerInfoBase): boolean;
-        _onPointerMove(target: Control, coordinates: Vector2, pointerId: number, pi: PointerInfoBase): void;
-        _onPointerUp(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean): void;
+        _draw(context: BABYLON.ICanvasRenderingContext): void;
+        _onPointerDown(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, pi: BABYLON.PointerInfoBase): boolean;
+        _onPointerMove(target: Control, coordinates: BABYLON.Vector2, pointerId: number, pi: BABYLON.PointerInfoBase): void;
+        _onPointerUp(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean): void;
         protected _beforeRenderText(textWrapper: TextWrapper): TextWrapper;
         dispose(): void;
     }
@@ -2535,16 +2535,16 @@ declare module BABYLON.GUI {
          */
         constructor(name?: string | undefined);
         protected _getTypeName(): string;
-        _draw(context: ICanvasRenderingContext): void;
+        _draw(context: BABYLON.ICanvasRenderingContext): void;
         _measure(): void;
         protected _computeAlignment(parentMeasure: Measure): void;
         /**
          * Move one end of the line given 3D cartesian coordinates.
          * @param position Targeted world position
-         * @param scene Scene
+         * @param scene BABYLON.Scene
          * @param end (opt) Set to true to assign x2 and y2 coordinates of the line. Default assign to x1 and y1.
          */
-        moveToVector3(position: BABYLON.Vector3, scene: Scene, end?: boolean): void;
+        moveToVector3(position: BABYLON.Vector3, scene: BABYLON.Scene, end?: boolean): void;
         /**
          * Move one end of the line to a position in screen absolute space.
          * @param projectedPosition Position in screen absolute space (X, Y)
@@ -2619,7 +2619,7 @@ declare module BABYLON.GUI {
         set horizontalAlignment(value: number);
         set verticalAlignment(value: number);
         protected _getTypeName(): string;
-        _draw(context: ICanvasRenderingContext): void;
+        _draw(context: BABYLON.ICanvasRenderingContext): void;
         protected _additionalProcessing(): void;
         _measure(): void;
         protected _computeAlignment(): void;
@@ -2658,8 +2658,8 @@ declare module BABYLON.GUI {
          */
         constructor(name?: string | undefined);
         protected _getTypeName(): string;
-        _draw(context: ICanvasRenderingContext): void;
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, pi: PointerInfoBase): boolean;
+        _draw(context: BABYLON.ICanvasRenderingContext): void;
+        _onPointerDown(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, pi: BABYLON.PointerInfoBase): boolean;
         /**
          * Utility function to easily create a radio button with a header
          * @param title defines the label to use for the header
@@ -2693,10 +2693,10 @@ declare module BABYLON.GUI {
         protected _computeAdditionnalOffsetX(): 1 | 0;
         /** @hidden */
         protected _computeAdditionnalOffsetY(): 1 | 0;
-        protected _localDraw(context: ICanvasRenderingContext): void;
-        protected _additionalProcessing(parentMeasure: Measure, context: ICanvasRenderingContext): void;
+        protected _localDraw(context: BABYLON.ICanvasRenderingContext): void;
+        protected _additionalProcessing(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
         private _drawRoundedRect;
-        protected _clipForChildren(context: ICanvasRenderingContext): void;
+        protected _clipForChildren(context: BABYLON.ICanvasRenderingContext): void;
     }
 
 
@@ -2746,7 +2746,7 @@ declare module BABYLON.GUI {
          * @param control defines the control to add
          * @returns the current container
          */
-        addControl(control: Nullable<Control>): Container;
+        addControl(control: BABYLON.Nullable<Control>): Container;
         /**
          * Removes a control from the current container
          * @param control defines the control to remove
@@ -2801,7 +2801,7 @@ declare module BABYLON.GUI {
         resetWindow(): void;
         protected _getTypeName(): string;
         private _buildClientSizes;
-        protected _additionalProcessing(parentMeasure: Measure, context: ICanvasRenderingContext): void;
+        protected _additionalProcessing(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
         protected _postMeasure(): void;
         /**
          * Gets or sets the mouse wheel precision
@@ -2868,7 +2868,7 @@ declare module BABYLON.GUI {
         private _addBar;
         /** @hidden */
         private _attachWheel;
-        _renderHighlightSpecific(context: ICanvasRenderingContext): void;
+        _renderHighlightSpecific(context: BABYLON.ICanvasRenderingContext): void;
         /** Releases associated resources */
         dispose(): void;
     }
@@ -2911,13 +2911,13 @@ declare module BABYLON.GUI {
          * @param context
          * @hidden
          */
-        protected _additionalProcessing(parentMeasure: Measure, context: ICanvasRenderingContext): void;
+        protected _additionalProcessing(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
         /**
          * @param parentMeasure
          * @param context
          * @hidden
          */
-        _layout(parentMeasure: Measure, context: ICanvasRenderingContext): boolean;
+        _layout(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): boolean;
         private _scrollChildren;
         private _scrollChildrenWithBuckets;
         /**
@@ -2925,7 +2925,7 @@ declare module BABYLON.GUI {
          * @param invalidatedRectangle
          * @hidden
          */
-        _draw(context: ICanvasRenderingContext, invalidatedRectangle?: Measure): void;
+        _draw(context: BABYLON.ICanvasRenderingContext, invalidatedRectangle?: Measure): void;
         protected _postMeasure(): void;
     }
 
@@ -3265,9 +3265,9 @@ declare module BABYLON.GUI {
          * @hidden
          */
         protected _updateValueFromPointer(x: number, y: number): void;
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, pi: PointerInfoBase): boolean;
-        _onPointerMove(target: Control, coordinates: Vector2, pointerId: number, pi: PointerInfoBase): void;
-        _onPointerUp(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean): void;
+        _onPointerDown(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, pi: BABYLON.PointerInfoBase): boolean;
+        _onPointerMove(target: Control, coordinates: BABYLON.Vector2, pointerId: number, pi: BABYLON.PointerInfoBase): void;
+        _onPointerUp(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean): void;
         _onCanvasBlur(): void;
     }
 
@@ -3304,7 +3304,7 @@ declare module BABYLON.GUI {
          */
         constructor(name?: string | undefined);
         protected _getTypeName(): string;
-        _draw(context: ICanvasRenderingContext): void;
+        _draw(context: BABYLON.ICanvasRenderingContext): void;
         /**
          * Serializes the current control
          * @param serializationObject defined the JSON serialized object
@@ -3366,7 +3366,7 @@ declare module BABYLON.GUI {
         constructor(name?: string | undefined);
         protected _getTypeName(): string;
         protected _getThumbThickness(): number;
-        _draw(context: ICanvasRenderingContext): void;
+        _draw(context: BABYLON.ICanvasRenderingContext): void;
         private _first;
         private _originX;
         private _originY;
@@ -3376,7 +3376,7 @@ declare module BABYLON.GUI {
          * @hidden
          */
         protected _updateValueFromPointer(x: number, y: number): void;
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, pi: PointerInfoBase): boolean;
+        _onPointerDown(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, pi: BABYLON.PointerInfoBase): boolean;
     }
 
 
@@ -3401,7 +3401,7 @@ declare module BABYLON.GUI {
         constructor(name?: string | undefined);
         protected _getTypeName(): string;
         protected _getThumbThickness(): number;
-        _draw(context: ICanvasRenderingContext): void;
+        _draw(context: BABYLON.ICanvasRenderingContext): void;
         private _first;
         private _originX;
         private _originY;
@@ -3411,7 +3411,7 @@ declare module BABYLON.GUI {
          * @hidden
          */
         protected _updateValueFromPointer(x: number, y: number): void;
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, pi: PointerInfoBase): boolean;
+        _onPointerDown(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, pi: BABYLON.PointerInfoBase): boolean;
     }
 
 
@@ -3446,7 +3446,7 @@ declare module BABYLON.GUI {
          */
         constructor(name?: string | undefined);
         protected _getTypeName(): string;
-        _draw(context: ICanvasRenderingContext): void;
+        _draw(context: BABYLON.ICanvasRenderingContext): void;
     }
 
 
@@ -3495,8 +3495,8 @@ declare module BABYLON.GUI {
          * @param context
          * @hidden
          */
-        protected _preMeasure(parentMeasure: Measure, context: ICanvasRenderingContext): void;
-        protected _additionalProcessing(parentMeasure: Measure, context: ICanvasRenderingContext): void;
+        protected _preMeasure(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
+        protected _additionalProcessing(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
         protected _postMeasure(): void;
         /**
          * Serializes the current control
@@ -3570,7 +3570,7 @@ declare module BABYLON.GUI {
         /**
          * Function used to split a string into words. By default, a string is split at each space character found
          */
-        wordSplittingFunction: Nullable<(line: string) => string[]>;
+        wordSplittingFunction: BABYLON.Nullable<(line: string) => string[]>;
         /**
          * Return the line list (you may need to use the onLinesReadyObservable to make sure the list is ready)
          */
@@ -3666,21 +3666,21 @@ declare module BABYLON.GUI {
          */
         name?: string | undefined, text?: string);
         protected _getTypeName(): string;
-        protected _processMeasures(parentMeasure: Measure, context: ICanvasRenderingContext): void;
+        protected _processMeasures(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
         private _drawText;
         /**
          * @param context
          * @hidden
          */
-        _draw(context: ICanvasRenderingContext): void;
-        protected _applyStates(context: ICanvasRenderingContext): void;
-        protected _breakLines(refWidth: number, refHeight: number, context: ICanvasRenderingContext): object[];
-        protected _parseLine(line: string | undefined, context: ICanvasRenderingContext): object;
+        _draw(context: BABYLON.ICanvasRenderingContext): void;
+        protected _applyStates(context: BABYLON.ICanvasRenderingContext): void;
+        protected _breakLines(refWidth: number, refHeight: number, context: BABYLON.ICanvasRenderingContext): object[];
+        protected _parseLine(line: string | undefined, context: BABYLON.ICanvasRenderingContext): object;
         private _getCharsToRemove;
-        protected _parseLineEllipsis(line: string | undefined, width: number, context: ICanvasRenderingContext): object;
-        protected _parseLineWordWrap(line: string | undefined, width: number, context: ICanvasRenderingContext): object[];
-        protected _parseLineWordWrapEllipsis(line: string | undefined, width: number, height: number, context: ICanvasRenderingContext): object[];
-        protected _renderLines(context: ICanvasRenderingContext): void;
+        protected _parseLineEllipsis(line: string | undefined, width: number, context: BABYLON.ICanvasRenderingContext): object;
+        protected _parseLineWordWrap(line: string | undefined, width: number, context: BABYLON.ICanvasRenderingContext): object[];
+        protected _parseLineWordWrapEllipsis(line: string | undefined, width: number, height: number, context: BABYLON.ICanvasRenderingContext): object[];
+        protected _renderLines(context: BABYLON.ICanvasRenderingContext): void;
         private _computeHeightForLinesOf;
         /**
          * Given a width constraint applied on the text block, find the expected height
@@ -3784,20 +3784,20 @@ declare module BABYLON.GUI {
          * @param deltaY
          * @hidden
          */
-        _processPicking(x: number, y: number, pi: PointerInfoBase, type: number, pointerId: number, buttonIndex: number, deltaX?: number, deltaY?: number): boolean;
+        _processPicking(x: number, y: number, pi: BABYLON.PointerInfoBase, type: number, pointerId: number, buttonIndex: number, deltaX?: number, deltaY?: number): boolean;
         /**
          * @param target
          * @param pi
          * @hidden
          */
-        _onPointerEnter(target: Control, pi: PointerInfoBase): boolean;
+        _onPointerEnter(target: Control, pi: BABYLON.PointerInfoBase): boolean;
         /**
          * @param target
          * @param pi
          * @param force
          * @hidden
          */
-        _onPointerOut(target: Control, pi: PointerInfoBase, force?: boolean): void;
+        _onPointerOut(target: Control, pi: BABYLON.PointerInfoBase, force?: boolean): void;
         /**
          * @param target
          * @param coordinates
@@ -3806,7 +3806,7 @@ declare module BABYLON.GUI {
          * @param pi
          * @hidden
          */
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, pi: PointerInfoBase): boolean;
+        _onPointerDown(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, pi: BABYLON.PointerInfoBase): boolean;
         /**
          * @param target
          * @param coordinates
@@ -3816,7 +3816,7 @@ declare module BABYLON.GUI {
          * @param pi
          * @hidden
          */
-        _onPointerUp(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean, pi: PointerInfoBase): void;
+        _onPointerUp(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean, pi: BABYLON.PointerInfoBase): void;
     }
 
 
@@ -3886,7 +3886,7 @@ declare module BABYLON.GUI {
         private _connectedInputTexts;
         private _onKeyPressObserver;
         /** Gets the input text control currently attached to the keyboard */
-        get connectedInputText(): Nullable<InputText>;
+        get connectedInputText(): BABYLON.Nullable<InputText>;
         /**
          * Connects the keyboard with an input text control
          *
@@ -4029,7 +4029,7 @@ declare module BABYLON.GUI {
          * @param parentMatrix defines the parent matrix to multiply by (can be null)
          * @param result defines the target matrix
          */
-        static ComposeToRef(tx: number, ty: number, angle: number, scaleX: number, scaleY: number, parentMatrix: Nullable<Matrix2D>, result: Matrix2D): void;
+        static ComposeToRef(tx: number, ty: number, angle: number, scaleX: number, scaleY: number, parentMatrix: BABYLON.Nullable<Matrix2D>, result: Matrix2D): void;
     }
 
 
@@ -4137,11 +4137,11 @@ declare module BABYLON.GUI {
         get y(): string | number;
         set y(value: string | number);
         /** Gets or sets the control associated with this point */
-        get control(): Nullable<Control>;
-        set control(value: Nullable<Control>);
+        get control(): BABYLON.Nullable<Control>;
+        set control(value: BABYLON.Nullable<Control>);
         /** Gets or sets the mesh associated with this point */
-        get mesh(): Nullable<AbstractMesh>;
-        set mesh(value: Nullable<AbstractMesh>);
+        get mesh(): BABYLON.Nullable<BABYLON.AbstractMesh>;
+        set mesh(value: BABYLON.Nullable<BABYLON.AbstractMesh>);
         /** Resets links */
         resetLinks(): void;
         /**
@@ -4159,7 +4159,7 @@ declare module BABYLON.GUI {
      * Define a style used by control to automatically setup properties based on a template.
      * Only support font related properties so far
      */
-    export class Style implements IDisposable {
+    export class Style implements BABYLON.IDisposable {
         private _fontFamily;
         private _fontStyle;
         private _fontWeight;
@@ -4338,7 +4338,7 @@ declare module BABYLON.GUI {
          * @param onSuccess defines the callback called on layout load successfully.
          * @param onError defines the callback called on layout load failure.
          */
-        loadLayout(xmlFile: any, rootNode: any, onSuccess?: Nullable<() => void>, onError?: Nullable<(error: string) => void>): void;
+        loadLayout(xmlFile: any, rootNode: any, onSuccess?: BABYLON.Nullable<() => void>, onError?: BABYLON.Nullable<(error: string) => void>): void;
         /**
          * Initiates the xml layout loading asynchronously
          * @param xmlFile defines the xml layout to load
@@ -4354,7 +4354,7 @@ declare module BABYLON.GUI {
      * Handles a BABYLON.FollowBehavior, SixDofBehavior and BABYLON.SurfaceMagnetismBehavior
      * @since 5.0.0
      */
-    export class DefaultBehavior implements Behavior<Mesh> {
+    export class DefaultBehavior implements BABYLON.Behavior<BABYLON.Mesh> {
         private _scene;
         private _followBehavior;
         private _sixDofDragBehavior;
@@ -4368,7 +4368,7 @@ declare module BABYLON.GUI {
         /**
          * Attached node of this behavior
          */
-        attachedNode: Nullable<Mesh>;
+        attachedNode: BABYLON.Nullable<BABYLON.Mesh>;
         /**
          *  The name of the behavior
          */
@@ -4407,7 +4407,7 @@ declare module BABYLON.GUI {
          * @param draggablesMeshes Descendant meshes that can be used for dragging the owner mesh
          * @param sceneUnderstandingMeshes Meshes from the scene understanding that will be used for surface magnetism
          */
-        attach(ownerMesh: Mesh, draggablesMeshes?: Mesh[], sceneUnderstandingMeshes?: AbstractMesh[]): void;
+        attach(ownerMesh: BABYLON.Mesh, draggablesMeshes?: BABYLON.Mesh[], sceneUnderstandingMeshes?: BABYLON.AbstractMesh[]): void;
         /**
          *  Detaches the behavior from the mesh
          */
@@ -4427,7 +4427,7 @@ declare module BABYLON.GUI {
          */
         constructor(name?: string);
         protected _getTypeName(): string;
-        protected _createNode(scene: Scene): BABYLON.TransformNode;
+        protected _createNode(scene: BABYLON.Scene): BABYLON.TransformNode;
     }
 
 
@@ -4436,7 +4436,7 @@ declare module BABYLON.GUI {
      */
     export class Button3D extends AbstractButton3D {
         /** @hidden */
-        protected _currentMaterial: Material;
+        protected _currentMaterial: BABYLON.Material;
         /**
          * Creates a new button
          * @param name defines the control name
@@ -4448,8 +4448,8 @@ declare module BABYLON.GUI {
          */
         protected _applyFacade(facadeTexture: AdvancedDynamicTexture): void;
         protected _getTypeName(): string;
-        protected _createNode(scene: Scene): TransformNode;
-        protected _affectMaterial(mesh: AbstractMesh): void;
+        protected _createNode(scene: BABYLON.Scene): BABYLON.TransformNode;
+        protected _affectMaterial(mesh: BABYLON.AbstractMesh): void;
         /**
          * Releases all associated resources
          */
@@ -4502,7 +4502,7 @@ declare module BABYLON.GUI {
          * This function will be called everytime a new control is added
          */
         protected _arrangeChildren(): void;
-        protected _createNode(scene: Scene): Nullable<BABYLON.TransformNode>;
+        protected _createNode(scene: BABYLON.Scene): BABYLON.Nullable<BABYLON.TransformNode>;
         /**
          * Removes a control from the children of this control
          * @param control defines the control to remove
@@ -4559,7 +4559,7 @@ declare module BABYLON.GUI {
     /**
      * Class used as base class for controls
      */
-    export class Control3D implements IDisposable, IBehaviorAware<Control3D> {
+    export class Control3D implements BABYLON.IDisposable, BABYLON.IBehaviorAware<Control3D> {
         /** Defines the control name */
         name?: string | undefined;
         /** @hidden */
@@ -4612,34 +4612,34 @@ declare module BABYLON.GUI {
         /**
          * Gets or sets the parent container
          */
-        parent: Nullable<Container3D>;
+        parent: BABYLON.Nullable<Container3D>;
         private _behaviors;
         /**
          * Gets the list of attached behaviors
          * @see https://doc.babylonjs.com/features/behaviour
          */
-        get behaviors(): Behavior<Control3D>[];
+        get behaviors(): BABYLON.Behavior<Control3D>[];
         /**
          * Attach a behavior to the control
          * @see https://doc.babylonjs.com/features/behaviour
          * @param behavior defines the behavior to attach
          * @returns the current control
          */
-        addBehavior(behavior: Behavior<Control3D>): Control3D;
+        addBehavior(behavior: BABYLON.Behavior<Control3D>): Control3D;
         /**
          * Remove an attached behavior
          * @see https://doc.babylonjs.com/features/behaviour
          * @param behavior defines the behavior to attach
          * @returns the current control
          */
-        removeBehavior(behavior: Behavior<Control3D>): Control3D;
+        removeBehavior(behavior: BABYLON.Behavior<Control3D>): Control3D;
         /**
          * Gets an attached behavior by name
          * @param name defines the name of the behavior to look for
          * @see https://doc.babylonjs.com/features/behaviour
          * @returns null if behavior was not found else the requested behavior
          */
-        getBehaviorByName(name: string): Nullable<Behavior<Control3D>>;
+        getBehaviorByName(name: string): BABYLON.Nullable<BABYLON.Behavior<Control3D>>;
         /** Gets or sets a boolean indicating if the control is visible */
         get isVisible(): boolean;
         set isVisible(value: boolean);
@@ -4663,30 +4663,30 @@ declare module BABYLON.GUI {
         /**
          * Gets the transform node used by this control
          */
-        get node(): Nullable<TransformNode>;
+        get node(): BABYLON.Nullable<BABYLON.TransformNode>;
         /**
          * Gets the mesh used to render this control
          */
-        get mesh(): Nullable<BABYLON.AbstractMesh>;
+        get mesh(): BABYLON.Nullable<BABYLON.AbstractMesh>;
         /**
          * Link the control as child of the given node
          * @param node defines the node to link to. Use null to unlink the control
          * @returns the current control
          */
-        linkToTransformNode(node: Nullable<TransformNode>): Control3D;
+        linkToTransformNode(node: BABYLON.Nullable<BABYLON.TransformNode>): Control3D;
         /**
          * @param scene
          * @hidden*
          */
-        _prepareNode(scene: Scene): void;
-        protected _injectGUI3DReservedDataStore(node: TransformNode): any;
+        _prepareNode(scene: BABYLON.Scene): void;
+        protected _injectGUI3DReservedDataStore(node: BABYLON.TransformNode): any;
         /**
          * Node creation.
          * Can be overriden by children
          * @param scene defines the scene where the node must be attached
          * @returns the attached node or null if none. Must return a Mesh or BABYLON.AbstractMesh if there is an attached visible object
          */
-        protected _createNode(scene: Scene): Nullable<TransformNode>;
+        protected _createNode(scene: BABYLON.Scene): BABYLON.Nullable<BABYLON.TransformNode>;
         /**
          * Affect a material to the given mesh
          * @param mesh defines the mesh which will represent the control
@@ -4730,7 +4730,7 @@ declare module BABYLON.GUI {
          * @param pointerId
          * @hidden
          */
-        forcePointerUp(pointerId?: Nullable<number>): void;
+        forcePointerUp(pointerId?: BABYLON.Nullable<number>): void;
         /**
          * @param type
          * @param pickedPoint
@@ -4739,7 +4739,7 @@ declare module BABYLON.GUI {
          * @param buttonIndex
          * @hidden
          */
-        _processObservables(type: number, pickedPoint: BABYLON.Vector3, originMeshPosition: Nullable<BABYLON.Vector3>, pointerId: number, buttonIndex: number): boolean;
+        _processObservables(type: number, pickedPoint: BABYLON.Vector3, originMeshPosition: BABYLON.Nullable<BABYLON.Vector3>, pointerId: number, buttonIndex: number): boolean;
         /** @hidden */
         _disposeNode(): void;
         /**
@@ -4757,8 +4757,8 @@ declare module BABYLON.GUI {
         /**
          * Gets or sets the radius of the cylinder where to project controls (5 by default)
          */
-        get radius(): float;
-        set radius(value: float);
+        get radius(): BABYLON.float;
+        set radius(value: BABYLON.float);
         protected _mapGridNode(control: Control3D, nodePosition: BABYLON.Vector3): void;
         private _cylindricalMapping;
     }
@@ -4774,13 +4774,13 @@ declare module BABYLON.GUI {
          * The hand constraint behavior setting the transformation of this node
          */
         get handConstraintBehavior(): BABYLON.HandConstraintBehavior;
-        protected _createNode(scene: Scene): Nullable<TransformNode>;
+        protected _createNode(scene: BABYLON.Scene): BABYLON.Nullable<BABYLON.TransformNode>;
         /**
          * Creates a hand menu GUI 3D control
-         * @param xr the WebXRExperienceHelper used to link this control to the enabled WebXRHandTracking feature
+         * @param xr the BABYLON.WebXRExperienceHelper used to link this control to the enabled WebXRHandTracking feature
          * @param name name of the hand menu
          */
-        constructor(xr: WebXRExperienceHelper, name?: string);
+        constructor(xr: BABYLON.WebXRExperienceHelper, name?: string);
         /**
          * Disposes the hand menu
          */
@@ -4824,9 +4824,9 @@ declare module BABYLON.GUI {
          */
         constructor(name?: string, _shareMaterials?: boolean);
         protected _getTypeName(): string;
-        protected _createNode(scene: Scene): TransformNode;
+        protected _createNode(scene: BABYLON.Scene): BABYLON.TransformNode;
         private _createMaterial;
-        protected _affectMaterial(mesh: Mesh): void;
+        protected _affectMaterial(mesh: BABYLON.Mesh): void;
         /**
          * Releases all associated resources
          */
@@ -4863,8 +4863,8 @@ declare module BABYLON.GUI {
         /**
          * Text to be displayed on the tooltip shown when hovering on the button. When set to null tooltip is disabled. (Default: null)
          */
-        set tooltipText(text: Nullable<string>);
-        get tooltipText(): Nullable<string>;
+        set tooltipText(text: BABYLON.Nullable<string>);
+        get tooltipText(): BABYLON.Nullable<string>;
         /**
          * Gets or sets text for the button
          */
@@ -4899,7 +4899,7 @@ declare module BABYLON.GUI {
         constructor(name?: string, shareMaterials?: boolean);
         protected _getTypeName(): string;
         private _rebuildContent;
-        protected _createNode(scene: Scene): TransformNode;
+        protected _createNode(scene: BABYLON.Scene): BABYLON.TransformNode;
         protected _applyFacade(facadeTexture: AdvancedDynamicTexture): void;
         private _createBackMaterial;
         private _createFrontMaterial;
@@ -5015,14 +5015,14 @@ declare module BABYLON.GUI {
          * @hidden
          */
         _updatePivot(): void;
-        protected _createNode(scene: Scene): TransformNode;
+        protected _createNode(scene: BABYLON.Scene): BABYLON.TransformNode;
         private _attachContentPlateBehavior;
-        protected _affectMaterial(mesh: AbstractMesh): void;
+        protected _affectMaterial(mesh: BABYLON.AbstractMesh): void;
         /**
          * @param scene
          * @hidden*
          */
-        _prepareNode(scene: Scene): void;
+        _prepareNode(scene: BABYLON.Scene): void;
         /**
          * Resets the aspect and pose of the slate so it is right in front of the active camera, facing towards it.
          * @param resetAspect Should the slate's dimensions/aspect ratio be reset as well
@@ -5042,16 +5042,16 @@ declare module BABYLON.GUI {
      */
     export class MeshButton3D extends Button3D {
         /** @hidden */
-        protected _currentMesh: Mesh;
+        protected _currentMesh: BABYLON.Mesh;
         /**
          * Creates a new 3D button based on a mesh
          * @param mesh mesh to become a 3D button
          * @param name defines the control name
          */
-        constructor(mesh: Mesh, name?: string);
+        constructor(mesh: BABYLON.Mesh, name?: string);
         protected _getTypeName(): string;
-        protected _createNode(scene: Scene): TransformNode;
-        protected _affectMaterial(mesh: AbstractMesh): void;
+        protected _createNode(scene: BABYLON.Scene): BABYLON.TransformNode;
+        protected _affectMaterial(mesh: BABYLON.AbstractMesh): void;
     }
 
 
@@ -5082,7 +5082,7 @@ declare module BABYLON.GUI {
         get isPinned(): boolean;
         set isPinned(value: boolean);
         private _createPinButton;
-        protected _createNode(scene: Scene): Nullable<TransformNode>;
+        protected _createNode(scene: BABYLON.Scene): BABYLON.Nullable<BABYLON.TransformNode>;
         protected _finalProcessing(): void;
         /**
          * Creates a near menu GUI 3D control
@@ -5112,8 +5112,8 @@ declare module BABYLON.GUI {
         /**
          * Gets or sets the number of iteration to use to scatter the controls (100 by default)
          */
-        get iteration(): float;
-        set iteration(value: float);
+        get iteration(): BABYLON.float;
+        set iteration(value: BABYLON.float);
         protected _mapGridNode(control: Control3D, nodePosition: BABYLON.Vector3): void;
         private _scatterMapping;
         protected _finalProcessing(): void;
@@ -5155,7 +5155,7 @@ declare module BABYLON.GUI {
         /**
          * Gets the mesh used to render this control
          */
-        get mesh(): Nullable<AbstractMesh>;
+        get mesh(): BABYLON.Nullable<BABYLON.AbstractMesh>;
         /** Gets or sets minimum value */
         get minimum(): number;
         set minimum(value: number);
@@ -5182,8 +5182,8 @@ declare module BABYLON.GUI {
          * Gets the slider backplate material used by this control
          */
         get sliderBackplateMaterial(): MRDLBackplateMaterial;
-        protected _createNode(scene: Scene): TransformNode;
-        protected _affectMaterial(mesh: AbstractMesh): void;
+        protected _createNode(scene: BABYLON.Scene): BABYLON.TransformNode;
+        protected _affectMaterial(mesh: BABYLON.AbstractMesh): void;
         private _createBehavior;
         private _convertToPosition;
         private _convertToValue;
@@ -5202,8 +5202,8 @@ declare module BABYLON.GUI {
         /**
          * Gets or sets the radius of the sphere where to project controls (5 by default)
          */
-        get radius(): float;
-        set radius(value: float);
+        get radius(): BABYLON.float;
+        set radius(value: BABYLON.float);
         protected _mapGridNode(control: Control3D, nodePosition: BABYLON.Vector3): void;
         private _sphericalMapping;
     }
@@ -5252,7 +5252,7 @@ declare module BABYLON.GUI {
          * @param name defines the control name
          * @param collisionMesh mesh to track collisions with
          */
-        constructor(name?: string, collisionMesh?: Mesh);
+        constructor(name?: string, collisionMesh?: BABYLON.Mesh);
         /**
          * Whether the current interaction is caused by near interaction or not
          */
@@ -5270,7 +5270,7 @@ declare module BABYLON.GUI {
          * Sets the mesh used for testing input collision
          * @param collisionMesh the new collision mesh for the button
          */
-        set collisionMesh(collisionMesh: Mesh);
+        set collisionMesh(collisionMesh: BABYLON.Mesh);
         /**
          * Setter for if this TouchButton3D should be treated as a toggle button
          * @param value If this TouchHolographicButton should act like a toggle button
@@ -5300,7 +5300,7 @@ declare module BABYLON.GUI {
          */
         _generatePointerEventType(providedType: number, nearMeshPosition: BABYLON.Vector3, activeInteractionCount: number): number;
         protected _getTypeName(): string;
-        protected _createNode(scene: Scene): TransformNode;
+        protected _createNode(scene: BABYLON.Scene): BABYLON.TransformNode;
         /**
          * Releases all associated resources
          */
@@ -5352,12 +5352,12 @@ declare module BABYLON.GUI {
         /**
          * Gets the mesh used to render this control
          */
-        get mesh(): Nullable<AbstractMesh>;
+        get mesh(): BABYLON.Nullable<BABYLON.AbstractMesh>;
         /**
          * Text to be displayed on the tooltip shown when hovering on the button. When set to null tooltip is disabled. (Default: null)
          */
-        set tooltipText(text: Nullable<string>);
-        get tooltipText(): Nullable<string>;
+        set tooltipText(text: BABYLON.Nullable<string>);
+        get tooltipText(): BABYLON.Nullable<string>;
         /**
          * Gets or sets text for the button
          */
@@ -5396,7 +5396,7 @@ declare module BABYLON.GUI {
         constructor(name?: string, shareMaterials?: boolean);
         protected _getTypeName(): string;
         private _rebuildContent;
-        protected _createNode(scene: Scene): BABYLON.TransformNode;
+        protected _createNode(scene: BABYLON.Scene): BABYLON.TransformNode;
         protected _applyFacade(facadeTexture: AdvancedDynamicTexture): void;
         private _createBackMaterial;
         private _createFrontMaterial;
@@ -5430,9 +5430,9 @@ declare module BABYLON.GUI {
          */
         get backPlateMargin(): number;
         set backPlateMargin(value: number);
-        protected _createNode(scene: Scene): Nullable<TransformNode>;
-        protected _affectMaterial(mesh: AbstractMesh): void;
-        protected _mapGridNode(control: Control3D, nodePosition: Vector3): void;
+        protected _createNode(scene: BABYLON.Scene): BABYLON.Nullable<BABYLON.TransformNode>;
+        protected _affectMaterial(mesh: BABYLON.AbstractMesh): void;
+        protected _mapGridNode(control: Control3D, nodePosition: BABYLON.Vector3): void;
         protected _finalProcessing(): void;
         private _updateCurrentMinMax;
         private _updateMargins;
@@ -5469,16 +5469,16 @@ declare module BABYLON.GUI {
      */
     export class TouchMeshButton3D extends TouchButton3D {
         /** @hidden */
-        protected _currentMesh: Mesh;
+        protected _currentMesh: BABYLON.Mesh;
         /**
          * Creates a new 3D button based on a mesh
          * @param mesh mesh to become a 3D button. By default this is also the mesh for near interaction collision checking
          * @param name defines the control name
          */
-        constructor(mesh: Mesh, name?: string);
+        constructor(mesh: BABYLON.Mesh, name?: string);
         protected _getTypeName(): string;
-        protected _createNode(): TransformNode;
-        protected _affectMaterial(mesh: AbstractMesh): void;
+        protected _createNode(): BABYLON.TransformNode;
+        protected _affectMaterial(mesh: BABYLON.AbstractMesh): void;
     }
 
 
@@ -5512,14 +5512,14 @@ declare module BABYLON.GUI {
          * Gets or sets the number of columns requested (10 by default).
          * The panel will automatically compute the number of rows based on number of child controls.
          */
-        get columns(): int;
-        set columns(value: int);
+        get columns(): BABYLON.int;
+        set columns(value: BABYLON.int);
         /**
          * Gets or sets a the number of rows requested.
          * The panel will automatically compute the number of columns based on number of child controls.
          */
-        get rows(): int;
-        set rows(value: int);
+        get rows(): BABYLON.int;
+        set rows(value: BABYLON.int);
         /**
          * Creates new VolumeBasedPanel
          * @param name
@@ -5554,7 +5554,7 @@ declare module BABYLON.GUI {
      * Base class for SlateGizmo handles
      */
     export abstract class GizmoHandle {
-        protected _scene: Scene;
+        protected _scene: BABYLON.Scene;
         protected _state: HandleState;
         protected _materials: HandleMaterial[];
         private _dragStartObserver;
@@ -5590,7 +5590,7 @@ declare module BABYLON.GUI {
          * @param gizmo associated SlateGizmo
          * @param scene scene
          */
-        constructor(gizmo: SlateGizmo, scene: Scene);
+        constructor(gizmo: SlateGizmo, scene: BABYLON.Scene);
         protected _createMaterial(positionOffset?: BABYLON.Vector3): HandleMaterial;
         private _updateMaterial;
         /**
@@ -5672,16 +5672,16 @@ declare module BABYLON.GUI {
         /**
          * The slate attached to this gizmo
          */
-        set attachedSlate(control: Nullable<HolographicSlate>);
-        get attachedSlate(): Nullable<HolographicSlate>;
-        constructor(utilityLayer?: UtilityLayerRenderer);
+        set attachedSlate(control: BABYLON.Nullable<HolographicSlate>);
+        get attachedSlate(): BABYLON.Nullable<HolographicSlate>;
+        constructor(utilityLayer?: BABYLON.UtilityLayerRenderer);
         private _createNode;
         private _keepAspectRatio;
         private _clampDimensions;
         private _moveHandle;
         private _assignDragBehaviorCorners;
         private _assignDragBehaviorSides;
-        protected _attachedNodeChanged(value: Nullable<AbstractMesh>): void;
+        protected _attachedNodeChanged(value: BABYLON.Nullable<BABYLON.AbstractMesh>): void;
         /**
          * Updates the bounding box information for the gizmo
          */
@@ -5697,7 +5697,7 @@ declare module BABYLON.GUI {
      * Class used to manage 3D user interface
      * @see https://doc.babylonjs.com/how_to/gui3d
      */
-    export class GUI3DManager implements IDisposable {
+    export class GUI3DManager implements BABYLON.IDisposable {
         private _scene;
         private _sceneDisposeObserver;
         private _utilityLayer;
@@ -5719,23 +5719,23 @@ declare module BABYLON.GUI {
         /**
          * BABYLON.Observable raised when the point picked by the pointer events changed
          */
-        onPickedPointChangedObservable: BABYLON.Observable<Nullable<BABYLON.Vector3>>;
+        onPickedPointChangedObservable: BABYLON.Observable<BABYLON.Nullable<BABYLON.Vector3>>;
         /**
          * BABYLON.Observable raised when a picking happens
          */
-        onPickingObservable: BABYLON.Observable<Nullable<AbstractMesh>>;
+        onPickingObservable: BABYLON.Observable<BABYLON.Nullable<BABYLON.AbstractMesh>>;
         /** @hidden */
         _sharedMaterials: {
-            [key: string]: Material;
+            [key: string]: BABYLON.Material;
         };
         /** @hidden */
         _touchSharedMaterials: {
-            [key: string]: Material;
+            [key: string]: BABYLON.Material;
         };
         /** Gets the hosting scene */
-        get scene(): Scene;
+        get scene(): BABYLON.Scene;
         /** Gets associated utility layer */
-        get utilityLayer(): Nullable<BABYLON.UtilityLayerRenderer>;
+        get utilityLayer(): BABYLON.Nullable<BABYLON.UtilityLayerRenderer>;
         /** Gets the scaling for all UI elements owned by this manager */
         get controlScaling(): number;
         /** Sets the scaling adjustment for all UI elements owned by this manager */
@@ -5748,7 +5748,7 @@ declare module BABYLON.GUI {
          * Creates a new GUI3DManager
          * @param scene
          */
-        constructor(scene?: Scene);
+        constructor(scene?: BABYLON.Scene);
         private _handlePointerOut;
         private _doPicking;
         /**
@@ -5840,25 +5840,25 @@ declare module BABYLON.GUI {
         hoverPosition: BABYLON.Vector3;
         private _albedoTexture;
         /** Gets or sets the texture to use for albedo color */
-        albedoTexture: Nullable<BaseTexture>;
+        albedoTexture: BABYLON.Nullable<BABYLON.BaseTexture>;
         /**
          * Creates a new Fluent material
          * @param name defines the name of the material
          * @param scene defines the hosting scene
          */
-        constructor(name: string, scene?: Scene);
+        constructor(name: string, scene?: BABYLON.Scene);
         needAlphaBlending(): boolean;
         needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        getActiveTextures(): BaseTexture[];
-        hasTexture(texture: BaseTexture): boolean;
+        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh): boolean;
+        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+        getActiveTextures(): BABYLON.BaseTexture[];
+        hasTexture(texture: BABYLON.BaseTexture): boolean;
         dispose(forceDisposeEffect?: boolean): void;
         clone(name: string): FluentMaterial;
         serialize(): any;
         getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): FluentMaterial;
+        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): FluentMaterial;
     }
 
 
@@ -6003,22 +6003,22 @@ declare module BABYLON.GUI {
          */
         globalRightIndexTipPosition: BABYLON.Vector3;
         private _globalRightIndexTipPosition4;
-        constructor(name: string, scene?: Scene);
+        constructor(name: string, scene?: BABYLON.Scene);
         needAlphaBlending(): boolean;
         needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
+        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh): boolean;
+        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
         /**
          * Get the list of animatables in the material.
          * @returns the list of animatables object used in the material
          */
-        getAnimatables(): IAnimatable[];
+        getAnimatables(): BABYLON.IAnimatable[];
         dispose(forceDisposeEffect?: boolean): void;
         clone(name: string): FluentBackplateMaterial;
         serialize(): any;
         getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): FluentBackplateMaterial;
+        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): FluentBackplateMaterial;
     }
 
 
@@ -6198,22 +6198,22 @@ declare module BABYLON.GUI {
          */
         globalRightIndexTipPosition: BABYLON.Vector3;
         private _blobTexture;
-        constructor(name: string, scene?: Scene);
+        constructor(name: string, scene?: BABYLON.Scene);
         needAlphaBlending(): boolean;
         needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
+        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh): boolean;
+        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
         /**
          * Get the list of animatables in the material.
          * @returns the list of animatables object used in the material
          */
-        getAnimatables(): IAnimatable[];
+        getAnimatables(): BABYLON.IAnimatable[];
         dispose(forceDisposeEffect?: boolean): void;
         clone(name: string): FluentButtonMaterial;
         serialize(): any;
         getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): FluentButtonMaterial;
+        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): FluentButtonMaterial;
     }
 
 
@@ -6291,9 +6291,9 @@ declare module BABYLON.GUI {
         /**
          * Creates a handle material
          * @param name Name of the material
-         * @param scene Scene
+         * @param scene BABYLON.Scene
          */
-        constructor(name: string, scene: Scene);
+        constructor(name: string, scene: BABYLON.Scene);
         private _updateInterpolationTarget;
         /**
          * Disposes the handle material
@@ -6440,22 +6440,22 @@ declare module BABYLON.GUI {
          * Gets or sets the edge width of the backplate.
          */
         edgeLineGradientBlend: number;
-        constructor(name: string, scene?: Scene);
+        constructor(name: string, scene?: BABYLON.Scene);
         needAlphaBlending(): boolean;
         needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
+        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh): boolean;
+        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
         /**
          * Get the list of animatables in the material.
          * @returns the list of animatables object used in the material
          */
-        getAnimatables(): IAnimatable[];
+        getAnimatables(): BABYLON.IAnimatable[];
         dispose(forceDisposeEffect?: boolean): void;
         clone(name: string): MRDLBackplateMaterial;
         serialize(): any;
         getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): MRDLBackplateMaterial;
+        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): MRDLBackplateMaterial;
     }
 
 
@@ -6762,22 +6762,22 @@ declare module BABYLON.GUI {
          * @hidden
          */
         globalRightIndexMiddlePosition: BABYLON.Vector4;
-        constructor(name: string, scene?: Scene);
+        constructor(name: string, scene?: BABYLON.Scene);
         needAlphaBlending(): boolean;
         needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
+        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh): boolean;
+        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
         /**
          * Get the list of animatables in the material.
          * @returns the list of animatables object used in the material
          */
-        getAnimatables(): IAnimatable[];
+        getAnimatables(): BABYLON.IAnimatable[];
         dispose(forceDisposeEffect?: boolean): void;
         clone(name: string): MRDLSliderBarMaterial;
         serialize(): any;
         getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): MRDLSliderBarMaterial;
+        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): MRDLSliderBarMaterial;
     }
 
 
@@ -7084,22 +7084,22 @@ declare module BABYLON.GUI {
          * @hidden
          */
         globalRightIndexMiddlePosition: BABYLON.Vector4;
-        constructor(name: string, scene?: Scene);
+        constructor(name: string, scene?: BABYLON.Scene);
         needAlphaBlending(): boolean;
         needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
+        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh): boolean;
+        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
         /**
          * Get the list of animatables in the material.
          * @returns the list of animatables object used in the material
          */
-        getAnimatables(): IAnimatable[];
+        getAnimatables(): BABYLON.IAnimatable[];
         dispose(forceDisposeEffect?: boolean): void;
         clone(name: string): MRDLSliderThumbMaterial;
         serialize(): any;
         getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): MRDLSliderThumbMaterial;
+        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): MRDLSliderThumbMaterial;
     }