babylonjs-gui 5.0.0-rc.9 → 5.0.0

package/babylon.gui.module.d.ts

@@ -57,7 +57,8 @@ export class AdvancedDynamicTextureInstrumentation implements IDisposable {
 declare module "babylonjs-gui/2D/advancedDynamicTexture" {
 import { Nullable } from "babylonjs/types";
 import { Observable } from "babylonjs/Misc/observable";
-import { Vector2, Vector3, Matrix } from "babylonjs/Maths/math.vector";
+import { Matrix } from "babylonjs/Maths/math.vector";
+import { Vector2, Vector3 } from "babylonjs/Maths/math.vector";
 import { ClipboardInfo } from "babylonjs/Events/clipboardEvents";
 import { DynamicTexture } from "babylonjs/Materials/Textures/dynamicTexture";
 import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
@@ -2425,6 +2426,7 @@ import { TextWrapper } from "babylonjs-gui/2D/controls/textWrapper";
  * Class used to create a password control
  */
 export class InputPassword extends InputText {
+    protected _getTypeName(): string;
     protected _beforeRenderText(textWrapper: TextWrapper): TextWrapper;
 }
 
@@ -6257,7 +6259,8 @@ export * from "babylonjs-gui/3D/vector3WithInfo";
 }
 declare module "babylonjs-gui/3D/materials/fluent/fluentMaterial" {
 import { Nullable } from "babylonjs/types";
-import { Vector3, Matrix } from "babylonjs/Maths/math.vector";
+import { Matrix } from "babylonjs/Maths/math.vector";
+import { Vector3 } from "babylonjs/Maths/math.vector";
 import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
 import { MaterialDefines } from "babylonjs/Materials/materialDefines";
 import { PushMaterial } from "babylonjs/Materials/pushMaterial";
@@ -6370,7 +6373,8 @@ export const fluentVertexShader: {
 }
 declare module "babylonjs-gui/3D/materials/fluentBackplate/fluentBackplateMaterial" {
 import { Nullable } from "babylonjs/types";
-import { Matrix, Vector3, Vector4 } from "babylonjs/Maths/math.vector";
+import { Matrix } from "babylonjs/Maths/math.vector";
+import { Vector3, Vector4 } from "babylonjs/Maths/math.vector";
 import { IAnimatable } from "babylonjs/Animations/animatable.interface";
 import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
 import { PushMaterial } from "babylonjs/Materials/pushMaterial";
@@ -6547,7 +6551,8 @@ export const fluentBackplateVertexShader: {
 }
 declare module "babylonjs-gui/3D/materials/fluentButton/fluentButtonMaterial" {
 import { Nullable } from "babylonjs/types";
-import { Matrix, Vector3 } from "babylonjs/Maths/math.vector";
+import { Matrix } from "babylonjs/Maths/math.vector";
+import { Vector3 } from "babylonjs/Maths/math.vector";
 import { IAnimatable } from "babylonjs/Animations/animatable.interface";
 import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
 import { PushMaterial } from "babylonjs/Materials/pushMaterial";
@@ -6871,7 +6876,8 @@ export * from "babylonjs-gui/3D/materials/mrdl/mrdlBackplateMaterial";
 }
 declare module "babylonjs-gui/3D/materials/mrdl/mrdlBackplateMaterial" {
 import { Nullable } from "babylonjs/types";
-import { Matrix, Vector4 } from "babylonjs/Maths/math.vector";
+import { Matrix } from "babylonjs/Maths/math.vector";
+import { Vector4 } from "babylonjs/Maths/math.vector";
 import { IAnimatable } from "babylonjs/Animations/animatable.interface";
 import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
 import { PushMaterial } from "babylonjs/Materials/pushMaterial";
@@ -7021,7 +7027,8 @@ export class MRDLBackplateMaterial extends PushMaterial {
 }
 declare module "babylonjs-gui/3D/materials/mrdl/mrdlSliderBarMaterial" {
 import { Nullable } from "babylonjs/types";
-import { Matrix, Vector2, Vector3, Vector4 } from "babylonjs/Maths/math.vector";
+import { Matrix } from "babylonjs/Maths/math.vector";
+import { Vector2, Vector3, Vector4 } from "babylonjs/Maths/math.vector";
 import { IAnimatable } from "babylonjs/Animations/animatable.interface";
 import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
 import { Texture } from "babylonjs/Materials/Textures/texture";
@@ -7357,7 +7364,8 @@ export class MRDLSliderBarMaterial extends PushMaterial {
 }
 declare module "babylonjs-gui/3D/materials/mrdl/mrdlSliderThumbMaterial" {
 import { Nullable } from "babylonjs/types";
-import { Matrix, Vector2, Vector3, Vector4 } from "babylonjs/Maths/math.vector";
+import { Matrix } from "babylonjs/Maths/math.vector";
+import { Vector2, Vector3, Vector4 } from "babylonjs/Maths/math.vector";
 import { IAnimatable } from "babylonjs/Animations/animatable.interface";
 import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
 import { Texture } from "babylonjs/Materials/Textures/texture";
@@ -7774,10 +7782,10 @@ declare module "babylonjs-gui" {
 
 
 declare module BABYLON.GUI {
-        /**
+    /**
      * This class can be used to get instrumentation data from a AdvancedDynamicTexture object
      */
-    export class AdvancedDynamicTextureInstrumentation implements BABYLON.IDisposable {
+    export class AdvancedDynamicTextureInstrumentation implements IDisposable {
         /**
          * Define the instrumented AdvancedDynamicTexture.
          */
@@ -7865,7 +7873,7 @@ declare module BABYLON.GUI {
         /** @hidden */
         _shouldBlockPointer: boolean;
         /** @hidden */
-        _layerToDispose: BABYLON.Nullable<BABYLON.Layer>;
+        _layerToDispose: Nullable<BABYLON.Layer>;
         /** @hidden */
         _linkedControls: Control[];
         private _isFullscreen;
@@ -7968,7 +7976,7 @@ declare module BABYLON.GUI {
         /**
          * Gets the underlying layer used to render the texture when in fullscreen mode
          */
-        get layer(): BABYLON.Nullable<BABYLON.Layer>;
+        get layer(): Nullable<BABYLON.Layer>;
         /**
          * Gets the root container control
          */
@@ -7997,13 +8005,13 @@ declare module BABYLON.GUI {
          * @param name defines the name to search for
          * @return the first control found or null
          */
-        getControlByName(name: string): BABYLON.Nullable<Control>;
+        getControlByName(name: string): Nullable<Control>;
         private _getControlByKey;
         /**
          * Gets or sets the current focused control
          */
-        get focusedControl(): BABYLON.Nullable<IFocusableControl>;
-        set focusedControl(control: BABYLON.Nullable<IFocusableControl>);
+        get focusedControl(): Nullable<IFocusableControl>;
+        set focusedControl(control: Nullable<IFocusableControl>);
         /**
          * Gets or sets a boolean indicating if the texture must be rendered in background or foreground when in fullscreen mode
          */
@@ -8031,7 +8039,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?: BABYLON.Nullable<BABYLON.Scene>, generateMipMaps?: boolean, samplingMode?: number, invertY?: boolean);
+        constructor(name: string, width?: number, height?: number, scene?: Nullable<Scene>, generateMipMaps?: boolean, samplingMode?: number, invertY?: boolean);
         /**
          * Get the current class name of the texture useful for serialization or dynamic coding.
          * @returns "AdvancedDynamicTexture"
@@ -8101,14 +8109,14 @@ declare module BABYLON.GUI {
          * @param worldMatrix defines the world matrix to use
          * @returns the projected position
          */
-        getProjectedPosition(position: BABYLON.Vector3, worldMatrix: BABYLON.Matrix): BABYLON.Vector2;
+        getProjectedPosition(position: BABYLON.Vector3, worldMatrix: 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: BABYLON.Matrix): BABYLON.Vector3;
+        getProjectedPositionWithZ(position: BABYLON.Vector3, worldMatrix: Matrix): BABYLON.Vector3;
         private _checkUpdate;
         private _clearMeasure;
         private _render;
@@ -8168,7 +8176,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: BABYLON.AbstractMesh, supportPointerMove?: boolean): void;
+        attachToMesh(mesh: AbstractMesh, supportPointerMove?: boolean): void;
         /**
          * Move the focus to a specific control
          * @param control defines the control which will receive the focus
@@ -8221,7 +8229,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: BABYLON.AbstractMesh, width?: number, height?: number, supportPointerMove?: boolean, onlyAlphaTesting?: boolean, invertY?: boolean, materialSetupCallback?: (mesh: BABYLON.AbstractMesh, uniqueId: string, texture: AdvancedDynamicTexture, onlyAlphaTesting: boolean) => void): 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;
         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
@@ -8232,7 +8240,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: BABYLON.AbstractMesh, width?: number, height?: number, supportPointerMove?: boolean, invertY?: boolean): AdvancedDynamicTexture;
+        static CreateForMeshTexture(mesh: 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.
@@ -8246,7 +8254,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?: BABYLON.Nullable<BABYLON.Scene>, sampling?: number, adaptiveScaling?: boolean): AdvancedDynamicTexture;
+        static CreateFullscreenUI(name: string, foreground?: boolean, scene?: Nullable<Scene>, sampling?: number, adaptiveScaling?: boolean): AdvancedDynamicTexture;
         /**
          * Scales the texture
          * @param ratio the scale factor to apply to both width and height
@@ -8290,12 +8298,12 @@ declare module BABYLON.GUI {
         /**
          * Returns the image part of the button (if any)
          */
-        get image(): BABYLON.Nullable<Image>;
+        get image(): Nullable<Image>;
         private _textBlock;
         /**
          * Returns the image part of the button (if any)
          */
-        get textBlock(): BABYLON.Nullable<TextBlock>;
+        get textBlock(): Nullable<TextBlock>;
         /**
          * Creates a new Button
          * @param name defines the name of the button
@@ -8313,20 +8321,20 @@ declare module BABYLON.GUI {
          * @param deltaY
          * @hidden
          */
-        _processPicking(x: number, y: number, pi: BABYLON.PointerInfoBase, type: number, pointerId: number, buttonIndex: number, deltaX?: number, deltaY?: number): boolean;
+        _processPicking(x: number, y: number, pi: PointerInfoBase, type: number, pointerId: number, buttonIndex: number, deltaX?: number, deltaY?: number): boolean;
         /**
          * @param target
          * @param pi
          * @hidden
          */
-        _onPointerEnter(target: Control, pi: BABYLON.PointerInfoBase): boolean;
+        _onPointerEnter(target: Control, pi: PointerInfoBase): boolean;
         /**
          * @param target
          * @param pi
          * @param force
          * @hidden
          */
-        _onPointerOut(target: Control, pi: BABYLON.PointerInfoBase, force?: boolean): void;
+        _onPointerOut(target: Control, pi: PointerInfoBase, force?: boolean): void;
         /**
          * @param target
          * @param coordinates
@@ -8335,7 +8343,7 @@ declare module BABYLON.GUI {
          * @param pi
          * @hidden
          */
-        _onPointerDown(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, pi: BABYLON.PointerInfoBase): boolean;
+        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, pi: PointerInfoBase): boolean;
         /**
          * @param target
          * @param coordinates
@@ -8345,7 +8353,7 @@ declare module BABYLON.GUI {
          * @param pi
          * @hidden
          */
-        _onPointerUp(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean, pi: BABYLON.PointerInfoBase): void;
+        _onPointerUp(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean, pi: PointerInfoBase): void;
         /**
          * Serializes the current button
          * @param serializationObject defines the JSON serialized object
@@ -8425,7 +8433,7 @@ declare module BABYLON.GUI {
          * @param context
          * @hidden
          */
-        _draw(context: BABYLON.ICanvasRenderingContext): void;
+        _draw(context: ICanvasRenderingContext): void;
         /**
          * @param target
          * @param coordinates
@@ -8434,7 +8442,7 @@ declare module BABYLON.GUI {
          * @param pi
          * @hidden
          */
-        _onPointerDown(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, pi: BABYLON.PointerInfoBase): boolean;
+        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, pi: PointerInfoBase): boolean;
         /**
          * Utility function to easily create a checkbox with a header
          * @param title defines the label to use for the header
@@ -8503,14 +8511,14 @@ declare module BABYLON.GUI {
          * @param context
          * @hidden
          */
-        _draw(context: BABYLON.ICanvasRenderingContext): void;
+        _draw(context: ICanvasRenderingContext): void;
         private _pointerIsDown;
         private _updateValueFromPointer;
         private _isPointOnSquare;
         private _isPointOnWheel;
-        _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;
+        _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;
         _onCanvasBlur(): void;
         /**
          * This function expands the color picker by creating a color picker dialog with manual
@@ -8561,7 +8569,7 @@ declare module BABYLON.GUI {
         /** @hidden */
         protected _renderToIntermediateTexture: boolean;
         /** @hidden */
-        protected _intermediateTexture: BABYLON.Nullable<BABYLON.DynamicTexture>;
+        protected _intermediateTexture: 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);
@@ -8598,14 +8606,14 @@ declare module BABYLON.GUI {
          * @param name defines the child name to look for
          * @returns the child control if found
          */
-        getChildByName(name: string): BABYLON.Nullable<Control>;
+        getChildByName(name: string): 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): BABYLON.Nullable<Control>;
+        getChildByType(name: string, type: string): Nullable<Control>;
         /**
          * Search for a specific control in children
          * @param control defines the control to look for
@@ -8617,7 +8625,7 @@ declare module BABYLON.GUI {
          * @param control defines the control to add
          * @returns the current container
          */
-        addControl(control: BABYLON.Nullable<Control>): Container;
+        addControl(control: Nullable<Control>): Container;
         /**
          * Removes all controls from the current container
          * @returns the current container
@@ -8650,7 +8658,7 @@ declare module BABYLON.GUI {
          * @param context
          * @hidden
          */
-        protected _localDraw(context: BABYLON.ICanvasRenderingContext): void;
+        protected _localDraw(context: ICanvasRenderingContext): void;
         /**
          * @param host
          * @hidden
@@ -8663,20 +8671,20 @@ declare module BABYLON.GUI {
          * @param context
          * @hidden
          */
-        protected _processMeasures(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
+        protected _processMeasures(parentMeasure: Measure, context: ICanvasRenderingContext): void;
         /**
          * @param parentMeasure
          * @param context
          * @hidden
          */
-        _layout(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): boolean;
+        _layout(parentMeasure: Measure, context: ICanvasRenderingContext): boolean;
         protected _postMeasure(): void;
         /**
          * @param context
          * @param invalidatedRectangle
          * @hidden
          */
-        _draw(context: BABYLON.ICanvasRenderingContext, invalidatedRectangle?: Measure): void;
+        _draw(context: ICanvasRenderingContext, invalidatedRectangle?: Measure): void;
         getDescendantsToRef(results: Control[], directDescendantsOnly?: boolean, predicate?: (control: Control) => boolean): void;
         /**
          * @param x
@@ -8689,13 +8697,13 @@ declare module BABYLON.GUI {
          * @param deltaY
          * @hidden
          */
-        _processPicking(x: number, y: number, pi: BABYLON.Nullable<BABYLON.PointerInfoBase>, type: number, pointerId: number, buttonIndex: number, deltaX?: number, deltaY?: number): boolean;
+        _processPicking(x: number, y: number, pi: Nullable<PointerInfoBase>, type: number, pointerId: number, buttonIndex: number, deltaX?: number, deltaY?: number): boolean;
         /**
          * @param parentMeasure
          * @param context
          * @hidden
          */
-        protected _additionalProcessing(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
+        protected _additionalProcessing(parentMeasure: Measure, context: ICanvasRenderingContext): void;
         /**
          * Serializes the current control
          * @param serializationObject defined the JSON serialized object
@@ -8729,7 +8737,7 @@ declare module BABYLON.GUI {
         /** @hidden */
         _host: AdvancedDynamicTexture;
         /** Gets or sets the control parent */
-        parent: BABYLON.Nullable<Container>;
+        parent: Nullable<Container>;
         /** @hidden */
         _currentMeasure: Measure;
         /** @hidden */
@@ -8794,7 +8802,7 @@ declare module BABYLON.GUI {
         private _highlightColor;
         protected _highlightLineWidth: number;
         /** @hidden */
-        _linkedMesh: BABYLON.Nullable<BABYLON.TransformNode>;
+        _linkedMesh: Nullable<TransformNode>;
         private _fontSet;
         private _dummyVector2;
         private _downCount;
@@ -9045,8 +9053,8 @@ declare module BABYLON.GUI {
          * Gets or sets style
          * @see https://doc.babylonjs.com/how_to/gui#styles
          */
-        get style(): BABYLON.Nullable<Style>;
-        set style(value: BABYLON.Nullable<Style>);
+        get style(): Nullable<Style>;
+        set style(value: Nullable<Style>);
         /** @hidden */
         get _isFontSizeInPercentage(): boolean;
         /** Gets or sets font size in pixels */
@@ -9072,7 +9080,7 @@ declare module BABYLON.GUI {
         /**
          * Gets the current linked mesh (or null if none)
          */
-        get linkedMesh(): BABYLON.Nullable<BABYLON.TransformNode>;
+        get linkedMesh(): Nullable<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.
@@ -9221,7 +9229,7 @@ declare module BABYLON.GUI {
          * @param className defines the required type
          * @returns the ascendant or null if not found
          */
-        getAscendantOfClass(className: string): BABYLON.Nullable<Control>;
+        getAscendantOfClass(className: string): Nullable<Control>;
         /**
          * Mark control element as dirty
          * @param force force non visible elements to be marked too
@@ -9263,7 +9271,7 @@ declare module BABYLON.GUI {
          * @param position defines the target position
          * @param scene defines the hosting scene
          */
-        moveToVector3(position: BABYLON.Vector3, scene: BABYLON.Scene): void;
+        moveToVector3(position: BABYLON.Vector3, scene: 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
@@ -9283,7 +9291,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: BABYLON.Nullable<BABYLON.TransformNode>): void;
+        linkWithMesh(mesh: Nullable<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.
@@ -9326,7 +9334,7 @@ declare module BABYLON.GUI {
          * @param context
          * @hidden
          */
-        _intersectsRect(rect: Measure, context?: BABYLON.ICanvasRenderingContext): boolean;
+        _intersectsRect(rect: Measure, context?: ICanvasRenderingContext): boolean;
         /** @hidden */
         protected _computeAdditionnalOffsetX(): number;
         /** @hidden */
@@ -9349,34 +9357,34 @@ declare module BABYLON.GUI {
          * @param context
          * @hidden
          */
-        protected _transform(context?: BABYLON.ICanvasRenderingContext): void;
+        protected _transform(context?: ICanvasRenderingContext): void;
         /**
          * @param context
          * @hidden
          */
-        _renderHighlight(context: BABYLON.ICanvasRenderingContext): void;
+        _renderHighlight(context: ICanvasRenderingContext): void;
         /**
          * @param context
          * @hidden
          */
-        _renderHighlightSpecific(context: BABYLON.ICanvasRenderingContext): void;
+        _renderHighlightSpecific(context: ICanvasRenderingContext): void;
         /**
          * @param context
          * @hidden
          */
-        protected _applyStates(context: BABYLON.ICanvasRenderingContext): void;
+        protected _applyStates(context: ICanvasRenderingContext): void;
         /**
          * @param parentMeasure
          * @param context
          * @hidden
          */
-        _layout(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): boolean;
+        _layout(parentMeasure: Measure, context: ICanvasRenderingContext): boolean;
         /**
          * @param parentMeasure
          * @param context
          * @hidden
          */
-        protected _processMeasures(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
+        protected _processMeasures(parentMeasure: Measure, context: ICanvasRenderingContext): void;
         protected _evaluateClippingState(parentMeasure: Measure): void;
         /** @hidden */
         _measure(): void;
@@ -9385,24 +9393,24 @@ declare module BABYLON.GUI {
          * @param context
          * @hidden
          */
-        protected _computeAlignment(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
+        protected _computeAlignment(parentMeasure: Measure, context: ICanvasRenderingContext): void;
         /**
          * @param parentMeasure
          * @param context
          * @hidden
          */
-        protected _preMeasure(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
+        protected _preMeasure(parentMeasure: Measure, context: ICanvasRenderingContext): void;
         /**
          * @param parentMeasure
          * @param context
          * @hidden
          */
-        protected _additionalProcessing(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
+        protected _additionalProcessing(parentMeasure: Measure, context: ICanvasRenderingContext): void;
         /**
          * @param context
          * @hidden
          */
-        protected _clipForChildren(context: BABYLON.ICanvasRenderingContext): void;
+        protected _clipForChildren(context: ICanvasRenderingContext): void;
         private static _ClipMeasure;
         private _tmpMeasureA;
         private _clip;
@@ -9411,13 +9419,13 @@ declare module BABYLON.GUI {
          * @param invalidatedRectangle
          * @hidden
          */
-        _render(context: BABYLON.ICanvasRenderingContext, invalidatedRectangle?: BABYLON.Nullable<Measure>): boolean;
+        _render(context: ICanvasRenderingContext, invalidatedRectangle?: Nullable<Measure>): boolean;
         /**
          * @param context
          * @param invalidatedRectangle
          * @hidden
          */
-        _draw(context: BABYLON.ICanvasRenderingContext, invalidatedRectangle?: BABYLON.Nullable<Measure>): void;
+        _draw(context: ICanvasRenderingContext, invalidatedRectangle?: Nullable<Measure>): void;
         /**
          * Tests if a given coordinates belong to the current control
          * @param x defines x coordinate to test
@@ -9436,7 +9444,7 @@ declare module BABYLON.GUI {
          * @param deltaY
          * @hidden
          */
-        _processPicking(x: number, y: number, pi: BABYLON.Nullable<BABYLON.PointerInfoBase>, type: number, pointerId: number, buttonIndex: number, deltaX?: number, deltaY?: number): boolean;
+        _processPicking(x: number, y: number, pi: Nullable<PointerInfoBase>, type: number, pointerId: number, buttonIndex: number, deltaX?: number, deltaY?: number): boolean;
         /**
          * @param target
          * @param coordinates
@@ -9444,20 +9452,20 @@ declare module BABYLON.GUI {
          * @param pi
          * @hidden
          */
-        _onPointerMove(target: Control, coordinates: BABYLON.Vector2, pointerId: number, pi: BABYLON.Nullable<BABYLON.PointerInfoBase>): void;
+        _onPointerMove(target: Control, coordinates: BABYLON.Vector2, pointerId: number, pi: Nullable<PointerInfoBase>): void;
         /**
          * @param target
          * @param pi
          * @hidden
          */
-        _onPointerEnter(target: Control, pi: BABYLON.Nullable<BABYLON.PointerInfoBase>): boolean;
+        _onPointerEnter(target: Control, pi: Nullable<PointerInfoBase>): boolean;
         /**
          * @param target
          * @param pi
          * @param force
          * @hidden
          */
-        _onPointerOut(target: Control, pi: BABYLON.Nullable<BABYLON.PointerInfoBase>, force?: boolean): void;
+        _onPointerOut(target: Control, pi: Nullable<PointerInfoBase>, force?: boolean): void;
         /**
          * @param target
          * @param coordinates
@@ -9466,7 +9474,7 @@ declare module BABYLON.GUI {
          * @param pi
          * @hidden
          */
-        _onPointerDown(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, pi: BABYLON.Nullable<BABYLON.PointerInfoBase>): boolean;
+        _onPointerDown(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, pi: Nullable<PointerInfoBase>): boolean;
         /**
          * @param target
          * @param coordinates
@@ -9476,12 +9484,12 @@ declare module BABYLON.GUI {
          * @param pi
          * @hidden
          */
-        _onPointerUp(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean, pi?: BABYLON.Nullable<BABYLON.PointerInfoBase>): void;
+        _onPointerUp(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean, pi?: Nullable<PointerInfoBase>): void;
         /**
          * @param pointerId
          * @hidden
          */
-        _forcePointerUp(pointerId?: BABYLON.Nullable<number>): void;
+        _forcePointerUp(pointerId?: Nullable<number>): void;
         /**
          * @param deltaX
          * @param deltaY
@@ -9501,7 +9509,7 @@ declare module BABYLON.GUI {
          * @param deltaY
          * @hidden
          */
-        _processObservables(type: number, x: number, y: number, pi: BABYLON.Nullable<BABYLON.PointerInfoBase>, pointerId: number, buttonIndex: number, deltaX?: number, deltaY?: number): boolean;
+        _processObservables(type: number, x: number, y: number, pi: Nullable<PointerInfoBase>, pointerId: number, buttonIndex: number, deltaX?: number, deltaY?: number): boolean;
         private _prepareFont;
         /**
          * Serializes the current control
@@ -9563,7 +9571,7 @@ declare module BABYLON.GUI {
          * @param context
          * @hidden
          */
-        protected static drawEllipse(x: number, y: number, width: number, height: number, context: BABYLON.ICanvasRenderingContext): void;
+        protected static drawEllipse(x: number, y: number, width: number, height: number, context: ICanvasRenderingContext): void;
     }
 
 
@@ -9615,7 +9623,7 @@ declare module BABYLON.GUI {
          * @param name defines the control name
          */
         constructor(name?: string | undefined);
-        _draw(context: BABYLON.ICanvasRenderingContext): void;
+        _draw(context: ICanvasRenderingContext): void;
         protected _getTypeName(): string;
     }
 
@@ -9633,10 +9641,10 @@ declare module BABYLON.GUI {
          */
         constructor(name?: string | undefined);
         protected _getTypeName(): string;
-        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;
+        protected _localDraw(context: ICanvasRenderingContext): void;
+        protected _additionalProcessing(parentMeasure: Measure, context: ICanvasRenderingContext): void;
+        protected _clipForChildren(context: ICanvasRenderingContext): void;
+        _renderHighlightSpecific(context: ICanvasRenderingContext): void;
     }
 
 
@@ -9647,7 +9655,7 @@ declare module BABYLON.GUI {
     export class FocusableButton extends Button implements IFocusableControl {
         name?: string | undefined;
         /** Highlight color when button is focused */
-        focusedColor: BABYLON.Nullable<string>;
+        focusedColor: Nullable<string>;
         private _isFocused;
         private _unfocusedColor;
         /** BABYLON.Observable raised when the control gets the focus */
@@ -9655,7 +9663,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<BABYLON.IKeyboardEvent>;
+        onKeyboardEventProcessedObservable: BABYLON.Observable<IKeyboardEvent>;
         constructor(name?: string | undefined);
         /** @hidden */
         onBlur(): void;
@@ -9665,7 +9673,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(): BABYLON.Nullable<Control[]>;
+        keepsFocusWith(): Nullable<Control[]>;
         /**
          * Function to focus a button programmatically
          */
@@ -9678,7 +9686,7 @@ declare module BABYLON.GUI {
          * Handles the keyboard event
          * @param evt Defines the KeyboardEvent
          */
-        processKeyboard(evt: BABYLON.IKeyboardEvent): void;
+        processKeyboard(evt: IKeyboardEvent): void;
         /**
          * @param target
          * @param coordinates
@@ -9687,7 +9695,7 @@ declare module BABYLON.GUI {
          * @param pi
          * @hidden
          */
-        _onPointerDown(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, pi: BABYLON.PointerInfoBase): boolean;
+        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, pi: PointerInfoBase): boolean;
         /** @hidden */
         displose(): void;
     }
@@ -9709,12 +9717,12 @@ declare module BABYLON.GUI {
          * Function called to let the control handle keyboard events
          * @param evt defines the current keyboard event
          */
-        processKeyboard(evt: BABYLON.IKeyboardEvent): void;
+        processKeyboard(evt: 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(): BABYLON.Nullable<Control[]>;
+        keepsFocusWith(): Nullable<Control[]>;
         /**
          * Function to focus the control programmatically
          */
@@ -9756,13 +9764,13 @@ declare module BABYLON.GUI {
          * @param index defines the index of the row
          * @returns the row definition
          */
-        getRowDefinition(index: number): BABYLON.Nullable<ValueAndUnit>;
+        getRowDefinition(index: number): Nullable<ValueAndUnit>;
         /**
          * Gets the definition of a specific column
          * @param index defines the index of the column
          * @returns the column definition
          */
-        getColumnDefinition(index: number): BABYLON.Nullable<ValueAndUnit>;
+        getColumnDefinition(index: number): 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)
@@ -9799,7 +9807,7 @@ declare module BABYLON.GUI {
          * @param column defines the column to check
          * @returns the list of controls
          */
-        getChildrenAt(row: number, column: number): BABYLON.Nullable<Array<Control>>;
+        getChildrenAt(row: number, column: number): Nullable<Array<Control>>;
         /**
          * Gets a string representing the child cell info (row x column)
          * @param child defines the control to get info from
@@ -9841,9 +9849,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: BABYLON.ICanvasRenderingContext): void;
+        protected _additionalProcessing(parentMeasure: Measure, context: ICanvasRenderingContext): void;
         _flagDescendantsAsMatrixDirty(): void;
-        _renderHighlightSpecific(context: BABYLON.ICanvasRenderingContext): void;
+        _renderHighlightSpecific(context: ICanvasRenderingContext): void;
         /** Releases associated resources */
         dispose(): void;
         /**
@@ -9985,17 +9993,17 @@ declare module BABYLON.GUI {
         /**
          * Gets or sets the internal DOM image used to render the control
          */
-        set domImage(value: BABYLON.IImage);
-        get domImage(): BABYLON.IImage;
+        set domImage(value: IImage);
+        get domImage(): IImage;
         private _onImageLoaded;
         /**
          * Gets the image source url
          */
-        get source(): BABYLON.Nullable<string>;
+        get source(): Nullable<string>;
         /**
          * Gets or sets image source url
          */
-        set source(value: BABYLON.Nullable<string>);
+        set source(value: Nullable<string>);
         /**
          * Checks for svg document with icon id present
          * @param value
@@ -10031,7 +10039,7 @@ declare module BABYLON.GUI {
          * @param name defines the control name
          * @param url defines the image url
          */
-        constructor(name?: string | undefined, url?: BABYLON.Nullable<string>);
+        constructor(name?: string | undefined, url?: Nullable<string>);
         /**
          * Tests if a given coordinates belong to the current control
          * @param x defines x coordinate to test
@@ -10042,10 +10050,10 @@ declare module BABYLON.GUI {
         protected _getTypeName(): string;
         /** Force the control to synchronize with its content */
         synchronizeSizeWithContent(): void;
-        protected _processMeasures(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
+        protected _processMeasures(parentMeasure: Measure, context: ICanvasRenderingContext): void;
         private _prepareWorkingCanvasForOpaqueDetection;
         private _drawImage;
-        _draw(context: BABYLON.ICanvasRenderingContext): void;
+        _draw(context: ICanvasRenderingContext): void;
         private _renderNinePatch;
         dispose(): void;
         /** STRETCH_NONE */
@@ -10067,6 +10075,7 @@ declare module BABYLON.GUI {
      * Class used to create a password control
      */
     export class InputPassword extends InputText {
+        protected _getTypeName(): string;
         protected _beforeRenderText(textWrapper: TextWrapper): TextWrapper;
     }
 
@@ -10110,7 +10119,7 @@ declare module BABYLON.GUI {
         private _onClipboardObserver;
         private _onPointerDblTapObserver;
         /** @hidden */
-        _connectedVirtualKeyboard: BABYLON.Nullable<VirtualKeyboard>;
+        _connectedVirtualKeyboard: 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 */
@@ -10132,7 +10141,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<BABYLON.IKeyboardEvent>;
+        onKeyboardEventProcessedObservable: BABYLON.Observable<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 */
@@ -10215,14 +10224,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(): BABYLON.Nullable<Control[]>;
+        keepsFocusWith(): Nullable<Control[]>;
         /**
          * @param keyCode
          * @param key
          * @param evt
          * @hidden
          */
-        processKey(keyCode: number, key?: string, evt?: BABYLON.IKeyboardEvent): void;
+        processKey(keyCode: number, key?: string, evt?: IKeyboardEvent): void;
         /**
          * @param offset
          * @hidden
@@ -10239,7 +10248,7 @@ declare module BABYLON.GUI {
          * Handles the keyboard event
          * @param evt Defines the KeyboardEvent
          */
-        processKeyboard(evt: BABYLON.IKeyboardEvent): void;
+        processKeyboard(evt: IKeyboardEvent): void;
         /**
          * @param ev
          * @hidden
@@ -10255,10 +10264,10 @@ declare module BABYLON.GUI {
          * @hidden
          */
         private _onPasteText;
-        _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;
+        _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;
         protected _beforeRenderText(textWrapper: TextWrapper): TextWrapper;
         dispose(): void;
     }
@@ -10308,16 +10317,16 @@ declare module BABYLON.GUI {
          */
         constructor(name?: string | undefined);
         protected _getTypeName(): string;
-        _draw(context: BABYLON.ICanvasRenderingContext): void;
+        _draw(context: 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 BABYLON.Scene
+         * @param scene 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: BABYLON.Scene, end?: boolean): void;
+        moveToVector3(position: BABYLON.Vector3, scene: 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)
@@ -10392,7 +10401,7 @@ declare module BABYLON.GUI {
         set horizontalAlignment(value: number);
         set verticalAlignment(value: number);
         protected _getTypeName(): string;
-        _draw(context: BABYLON.ICanvasRenderingContext): void;
+        _draw(context: ICanvasRenderingContext): void;
         protected _additionalProcessing(): void;
         _measure(): void;
         protected _computeAlignment(): void;
@@ -10431,8 +10440,8 @@ declare module BABYLON.GUI {
          */
         constructor(name?: string | undefined);
         protected _getTypeName(): string;
-        _draw(context: BABYLON.ICanvasRenderingContext): void;
-        _onPointerDown(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, pi: BABYLON.PointerInfoBase): boolean;
+        _draw(context: ICanvasRenderingContext): void;
+        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, pi: PointerInfoBase): boolean;
         /**
          * Utility function to easily create a radio button with a header
          * @param title defines the label to use for the header
@@ -10466,10 +10475,10 @@ declare module BABYLON.GUI {
         protected _computeAdditionnalOffsetX(): 1 | 0;
         /** @hidden */
         protected _computeAdditionnalOffsetY(): 1 | 0;
-        protected _localDraw(context: BABYLON.ICanvasRenderingContext): void;
-        protected _additionalProcessing(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
+        protected _localDraw(context: ICanvasRenderingContext): void;
+        protected _additionalProcessing(parentMeasure: Measure, context: ICanvasRenderingContext): void;
         private _drawRoundedRect;
-        protected _clipForChildren(context: BABYLON.ICanvasRenderingContext): void;
+        protected _clipForChildren(context: ICanvasRenderingContext): void;
     }
 
 
@@ -10519,7 +10528,7 @@ declare module BABYLON.GUI {
          * @param control defines the control to add
          * @returns the current container
          */
-        addControl(control: BABYLON.Nullable<Control>): Container;
+        addControl(control: Nullable<Control>): Container;
         /**
          * Removes a control from the current container
          * @param control defines the control to remove
@@ -10574,7 +10583,7 @@ declare module BABYLON.GUI {
         resetWindow(): void;
         protected _getTypeName(): string;
         private _buildClientSizes;
-        protected _additionalProcessing(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
+        protected _additionalProcessing(parentMeasure: Measure, context: ICanvasRenderingContext): void;
         protected _postMeasure(): void;
         /**
          * Gets or sets the mouse wheel precision
@@ -10641,7 +10650,7 @@ declare module BABYLON.GUI {
         private _addBar;
         /** @hidden */
         private _attachWheel;
-        _renderHighlightSpecific(context: BABYLON.ICanvasRenderingContext): void;
+        _renderHighlightSpecific(context: ICanvasRenderingContext): void;
         /** Releases associated resources */
         dispose(): void;
     }
@@ -10684,13 +10693,13 @@ declare module BABYLON.GUI {
          * @param context
          * @hidden
          */
-        protected _additionalProcessing(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
+        protected _additionalProcessing(parentMeasure: Measure, context: ICanvasRenderingContext): void;
         /**
          * @param parentMeasure
          * @param context
          * @hidden
          */
-        _layout(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): boolean;
+        _layout(parentMeasure: Measure, context: ICanvasRenderingContext): boolean;
         private _scrollChildren;
         private _scrollChildrenWithBuckets;
         /**
@@ -10698,7 +10707,7 @@ declare module BABYLON.GUI {
          * @param invalidatedRectangle
          * @hidden
          */
-        _draw(context: BABYLON.ICanvasRenderingContext, invalidatedRectangle?: Measure): void;
+        _draw(context: ICanvasRenderingContext, invalidatedRectangle?: Measure): void;
         protected _postMeasure(): void;
     }
 
@@ -11038,9 +11047,9 @@ declare module BABYLON.GUI {
          * @hidden
          */
         protected _updateValueFromPointer(x: number, y: number): 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;
+        _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;
         _onCanvasBlur(): void;
     }
 
@@ -11077,7 +11086,7 @@ declare module BABYLON.GUI {
          */
         constructor(name?: string | undefined);
         protected _getTypeName(): string;
-        _draw(context: BABYLON.ICanvasRenderingContext): void;
+        _draw(context: ICanvasRenderingContext): void;
         /**
          * Serializes the current control
          * @param serializationObject defined the JSON serialized object
@@ -11139,7 +11148,7 @@ declare module BABYLON.GUI {
         constructor(name?: string | undefined);
         protected _getTypeName(): string;
         protected _getThumbThickness(): number;
-        _draw(context: BABYLON.ICanvasRenderingContext): void;
+        _draw(context: ICanvasRenderingContext): void;
         private _first;
         private _originX;
         private _originY;
@@ -11149,7 +11158,7 @@ declare module BABYLON.GUI {
          * @hidden
          */
         protected _updateValueFromPointer(x: number, y: number): void;
-        _onPointerDown(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, pi: BABYLON.PointerInfoBase): boolean;
+        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, pi: PointerInfoBase): boolean;
     }
 
 
@@ -11174,7 +11183,7 @@ declare module BABYLON.GUI {
         constructor(name?: string | undefined);
         protected _getTypeName(): string;
         protected _getThumbThickness(): number;
-        _draw(context: BABYLON.ICanvasRenderingContext): void;
+        _draw(context: ICanvasRenderingContext): void;
         private _first;
         private _originX;
         private _originY;
@@ -11184,7 +11193,7 @@ declare module BABYLON.GUI {
          * @hidden
          */
         protected _updateValueFromPointer(x: number, y: number): void;
-        _onPointerDown(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, pi: BABYLON.PointerInfoBase): boolean;
+        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, pi: PointerInfoBase): boolean;
     }
 
 
@@ -11219,7 +11228,7 @@ declare module BABYLON.GUI {
          */
         constructor(name?: string | undefined);
         protected _getTypeName(): string;
-        _draw(context: BABYLON.ICanvasRenderingContext): void;
+        _draw(context: ICanvasRenderingContext): void;
     }
 
 
@@ -11268,8 +11277,8 @@ declare module BABYLON.GUI {
          * @param context
          * @hidden
          */
-        protected _preMeasure(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
-        protected _additionalProcessing(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
+        protected _preMeasure(parentMeasure: Measure, context: ICanvasRenderingContext): void;
+        protected _additionalProcessing(parentMeasure: Measure, context: ICanvasRenderingContext): void;
         protected _postMeasure(): void;
         /**
          * Serializes the current control
@@ -11343,7 +11352,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: BABYLON.Nullable<(line: string) => string[]>;
+        wordSplittingFunction: Nullable<(line: string) => string[]>;
         /**
          * Return the line list (you may need to use the onLinesReadyObservable to make sure the list is ready)
          */
@@ -11439,21 +11448,21 @@ declare module BABYLON.GUI {
          */
         name?: string | undefined, text?: string);
         protected _getTypeName(): string;
-        protected _processMeasures(parentMeasure: Measure, context: BABYLON.ICanvasRenderingContext): void;
+        protected _processMeasures(parentMeasure: Measure, context: ICanvasRenderingContext): void;
         private _drawText;
         /**
          * @param context
          * @hidden
          */
-        _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;
+        _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;
         private _getCharsToRemove;
-        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;
+        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;
         private _computeHeightForLinesOf;
         /**
          * Given a width constraint applied on the text block, find the expected height
@@ -11557,20 +11566,20 @@ declare module BABYLON.GUI {
          * @param deltaY
          * @hidden
          */
-        _processPicking(x: number, y: number, pi: BABYLON.PointerInfoBase, type: number, pointerId: number, buttonIndex: number, deltaX?: number, deltaY?: number): boolean;
+        _processPicking(x: number, y: number, pi: PointerInfoBase, type: number, pointerId: number, buttonIndex: number, deltaX?: number, deltaY?: number): boolean;
         /**
          * @param target
          * @param pi
          * @hidden
          */
-        _onPointerEnter(target: Control, pi: BABYLON.PointerInfoBase): boolean;
+        _onPointerEnter(target: Control, pi: PointerInfoBase): boolean;
         /**
          * @param target
          * @param pi
          * @param force
          * @hidden
          */
-        _onPointerOut(target: Control, pi: BABYLON.PointerInfoBase, force?: boolean): void;
+        _onPointerOut(target: Control, pi: PointerInfoBase, force?: boolean): void;
         /**
          * @param target
          * @param coordinates
@@ -11579,7 +11588,7 @@ declare module BABYLON.GUI {
          * @param pi
          * @hidden
          */
-        _onPointerDown(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, pi: BABYLON.PointerInfoBase): boolean;
+        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, pi: PointerInfoBase): boolean;
         /**
          * @param target
          * @param coordinates
@@ -11589,7 +11598,7 @@ declare module BABYLON.GUI {
          * @param pi
          * @hidden
          */
-        _onPointerUp(target: Control, coordinates: BABYLON.Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean, pi: BABYLON.PointerInfoBase): void;
+        _onPointerUp(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean, pi: PointerInfoBase): void;
     }
 
 
@@ -11659,7 +11668,7 @@ declare module BABYLON.GUI {
         private _connectedInputTexts;
         private _onKeyPressObserver;
         /** Gets the input text control currently attached to the keyboard */
-        get connectedInputText(): BABYLON.Nullable<InputText>;
+        get connectedInputText(): Nullable<InputText>;
         /**
          * Connects the keyboard with an input text control
          *
@@ -11802,7 +11811,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: BABYLON.Nullable<Matrix2D>, result: Matrix2D): void;
+        static ComposeToRef(tx: number, ty: number, angle: number, scaleX: number, scaleY: number, parentMatrix: Nullable<Matrix2D>, result: Matrix2D): void;
     }
 
 
@@ -11910,11 +11919,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(): BABYLON.Nullable<Control>;
-        set control(value: BABYLON.Nullable<Control>);
+        get control(): Nullable<Control>;
+        set control(value: Nullable<Control>);
         /** Gets or sets the mesh associated with this point */
-        get mesh(): BABYLON.Nullable<BABYLON.AbstractMesh>;
-        set mesh(value: BABYLON.Nullable<BABYLON.AbstractMesh>);
+        get mesh(): Nullable<AbstractMesh>;
+        set mesh(value: Nullable<AbstractMesh>);
         /** Resets links */
         resetLinks(): void;
         /**
@@ -11932,7 +11941,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 BABYLON.IDisposable {
+    export class Style implements IDisposable {
         private _fontFamily;
         private _fontStyle;
         private _fontWeight;
@@ -12111,7 +12120,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?: BABYLON.Nullable<() => void>, onError?: BABYLON.Nullable<(error: string) => void>): void;
+        loadLayout(xmlFile: any, rootNode: any, onSuccess?: Nullable<() => void>, onError?: Nullable<(error: string) => void>): void;
         /**
          * Initiates the xml layout loading asynchronously
          * @param xmlFile defines the xml layout to load
@@ -12127,7 +12136,7 @@ declare module BABYLON.GUI {
      * Handles a BABYLON.FollowBehavior, SixDofBehavior and BABYLON.SurfaceMagnetismBehavior
      * @since 5.0.0
      */
-    export class DefaultBehavior implements BABYLON.Behavior<BABYLON.Mesh> {
+    export class DefaultBehavior implements Behavior<Mesh> {
         private _scene;
         private _followBehavior;
         private _sixDofDragBehavior;
@@ -12141,7 +12150,7 @@ declare module BABYLON.GUI {
         /**
          * Attached node of this behavior
          */
-        attachedNode: BABYLON.Nullable<BABYLON.Mesh>;
+        attachedNode: Nullable<Mesh>;
         /**
          *  The name of the behavior
          */
@@ -12180,7 +12189,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: BABYLON.Mesh, draggablesMeshes?: BABYLON.Mesh[], sceneUnderstandingMeshes?: BABYLON.AbstractMesh[]): void;
+        attach(ownerMesh: Mesh, draggablesMeshes?: Mesh[], sceneUnderstandingMeshes?: AbstractMesh[]): void;
         /**
          *  Detaches the behavior from the mesh
          */
@@ -12200,7 +12209,7 @@ declare module BABYLON.GUI {
          */
         constructor(name?: string);
         protected _getTypeName(): string;
-        protected _createNode(scene: BABYLON.Scene): BABYLON.TransformNode;
+        protected _createNode(scene: Scene): BABYLON.TransformNode;
     }
 
 
@@ -12209,7 +12218,7 @@ declare module BABYLON.GUI {
      */
     export class Button3D extends AbstractButton3D {
         /** @hidden */
-        protected _currentMaterial: BABYLON.Material;
+        protected _currentMaterial: Material;
         /**
          * Creates a new button
          * @param name defines the control name
@@ -12221,8 +12230,8 @@ declare module BABYLON.GUI {
          */
         protected _applyFacade(facadeTexture: AdvancedDynamicTexture): void;
         protected _getTypeName(): string;
-        protected _createNode(scene: BABYLON.Scene): BABYLON.TransformNode;
-        protected _affectMaterial(mesh: BABYLON.AbstractMesh): void;
+        protected _createNode(scene: Scene): TransformNode;
+        protected _affectMaterial(mesh: AbstractMesh): void;
         /**
          * Releases all associated resources
          */
@@ -12275,7 +12284,7 @@ declare module BABYLON.GUI {
          * This function will be called everytime a new control is added
          */
         protected _arrangeChildren(): void;
-        protected _createNode(scene: BABYLON.Scene): BABYLON.Nullable<BABYLON.TransformNode>;
+        protected _createNode(scene: Scene): Nullable<BABYLON.TransformNode>;
         /**
          * Removes a control from the children of this control
          * @param control defines the control to remove
@@ -12332,7 +12341,7 @@ declare module BABYLON.GUI {
     /**
      * Class used as base class for controls
      */
-    export class Control3D implements BABYLON.IDisposable, BABYLON.IBehaviorAware<Control3D> {
+    export class Control3D implements IDisposable, IBehaviorAware<Control3D> {
         /** Defines the control name */
         name?: string | undefined;
         /** @hidden */
@@ -12385,34 +12394,34 @@ declare module BABYLON.GUI {
         /**
          * Gets or sets the parent container
          */
-        parent: BABYLON.Nullable<Container3D>;
+        parent: Nullable<Container3D>;
         private _behaviors;
         /**
          * Gets the list of attached behaviors
          * @see https://doc.babylonjs.com/features/behaviour
          */
-        get behaviors(): BABYLON.Behavior<Control3D>[];
+        get behaviors(): 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: BABYLON.Behavior<Control3D>): Control3D;
+        addBehavior(behavior: 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: BABYLON.Behavior<Control3D>): Control3D;
+        removeBehavior(behavior: 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): BABYLON.Nullable<BABYLON.Behavior<Control3D>>;
+        getBehaviorByName(name: string): Nullable<Behavior<Control3D>>;
         /** Gets or sets a boolean indicating if the control is visible */
         get isVisible(): boolean;
         set isVisible(value: boolean);
@@ -12436,30 +12445,30 @@ declare module BABYLON.GUI {
         /**
          * Gets the transform node used by this control
          */
-        get node(): BABYLON.Nullable<BABYLON.TransformNode>;
+        get node(): Nullable<TransformNode>;
         /**
          * Gets the mesh used to render this control
          */
-        get mesh(): BABYLON.Nullable<BABYLON.AbstractMesh>;
+        get mesh(): 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: BABYLON.Nullable<BABYLON.TransformNode>): Control3D;
+        linkToTransformNode(node: Nullable<TransformNode>): Control3D;
         /**
          * @param scene
          * @hidden*
          */
-        _prepareNode(scene: BABYLON.Scene): void;
-        protected _injectGUI3DReservedDataStore(node: BABYLON.TransformNode): any;
+        _prepareNode(scene: Scene): void;
+        protected _injectGUI3DReservedDataStore(node: 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: BABYLON.Scene): BABYLON.Nullable<BABYLON.TransformNode>;
+        protected _createNode(scene: Scene): Nullable<TransformNode>;
         /**
          * Affect a material to the given mesh
          * @param mesh defines the mesh which will represent the control
@@ -12503,7 +12512,7 @@ declare module BABYLON.GUI {
          * @param pointerId
          * @hidden
          */
-        forcePointerUp(pointerId?: BABYLON.Nullable<number>): void;
+        forcePointerUp(pointerId?: Nullable<number>): void;
         /**
          * @param type
          * @param pickedPoint
@@ -12512,7 +12521,7 @@ declare module BABYLON.GUI {
          * @param buttonIndex
          * @hidden
          */
-        _processObservables(type: number, pickedPoint: BABYLON.Vector3, originMeshPosition: BABYLON.Nullable<BABYLON.Vector3>, pointerId: number, buttonIndex: number): boolean;
+        _processObservables(type: number, pickedPoint: BABYLON.Vector3, originMeshPosition: Nullable<BABYLON.Vector3>, pointerId: number, buttonIndex: number): boolean;
         /** @hidden */
         _disposeNode(): void;
         /**
@@ -12530,8 +12539,8 @@ declare module BABYLON.GUI {
         /**
          * Gets or sets the radius of the cylinder where to project controls (5 by default)
          */
-        get radius(): BABYLON.float;
-        set radius(value: BABYLON.float);
+        get radius(): float;
+        set radius(value: float);
         protected _mapGridNode(control: Control3D, nodePosition: BABYLON.Vector3): void;
         private _cylindricalMapping;
     }
@@ -12547,13 +12556,13 @@ declare module BABYLON.GUI {
          * The hand constraint behavior setting the transformation of this node
          */
         get handConstraintBehavior(): BABYLON.HandConstraintBehavior;
-        protected _createNode(scene: BABYLON.Scene): BABYLON.Nullable<BABYLON.TransformNode>;
+        protected _createNode(scene: Scene): Nullable<TransformNode>;
         /**
          * Creates a hand menu GUI 3D control
-         * @param xr the BABYLON.WebXRExperienceHelper used to link this control to the enabled WebXRHandTracking feature
+         * @param xr the WebXRExperienceHelper used to link this control to the enabled WebXRHandTracking feature
          * @param name name of the hand menu
          */
-        constructor(xr: BABYLON.WebXRExperienceHelper, name?: string);
+        constructor(xr: WebXRExperienceHelper, name?: string);
         /**
          * Disposes the hand menu
          */
@@ -12597,9 +12606,9 @@ declare module BABYLON.GUI {
          */
         constructor(name?: string, _shareMaterials?: boolean);
         protected _getTypeName(): string;
-        protected _createNode(scene: BABYLON.Scene): BABYLON.TransformNode;
+        protected _createNode(scene: Scene): TransformNode;
         private _createMaterial;
-        protected _affectMaterial(mesh: BABYLON.Mesh): void;
+        protected _affectMaterial(mesh: Mesh): void;
         /**
          * Releases all associated resources
          */
@@ -12636,8 +12645,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: BABYLON.Nullable<string>);
-        get tooltipText(): BABYLON.Nullable<string>;
+        set tooltipText(text: Nullable<string>);
+        get tooltipText(): Nullable<string>;
         /**
          * Gets or sets text for the button
          */
@@ -12672,7 +12681,7 @@ declare module BABYLON.GUI {
         constructor(name?: string, shareMaterials?: boolean);
         protected _getTypeName(): string;
         private _rebuildContent;
-        protected _createNode(scene: BABYLON.Scene): BABYLON.TransformNode;
+        protected _createNode(scene: Scene): TransformNode;
         protected _applyFacade(facadeTexture: AdvancedDynamicTexture): void;
         private _createBackMaterial;
         private _createFrontMaterial;
@@ -12788,14 +12797,14 @@ declare module BABYLON.GUI {
          * @hidden
          */
         _updatePivot(): void;
-        protected _createNode(scene: BABYLON.Scene): BABYLON.TransformNode;
+        protected _createNode(scene: Scene): TransformNode;
         private _attachContentPlateBehavior;
-        protected _affectMaterial(mesh: BABYLON.AbstractMesh): void;
+        protected _affectMaterial(mesh: AbstractMesh): void;
         /**
          * @param scene
          * @hidden*
          */
-        _prepareNode(scene: BABYLON.Scene): void;
+        _prepareNode(scene: 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
@@ -12815,16 +12824,16 @@ declare module BABYLON.GUI {
      */
     export class MeshButton3D extends Button3D {
         /** @hidden */
-        protected _currentMesh: BABYLON.Mesh;
+        protected _currentMesh: 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: BABYLON.Mesh, name?: string);
+        constructor(mesh: Mesh, name?: string);
         protected _getTypeName(): string;
-        protected _createNode(scene: BABYLON.Scene): BABYLON.TransformNode;
-        protected _affectMaterial(mesh: BABYLON.AbstractMesh): void;
+        protected _createNode(scene: Scene): TransformNode;
+        protected _affectMaterial(mesh: AbstractMesh): void;
     }
 
 
@@ -12855,7 +12864,7 @@ declare module BABYLON.GUI {
         get isPinned(): boolean;
         set isPinned(value: boolean);
         private _createPinButton;
-        protected _createNode(scene: BABYLON.Scene): BABYLON.Nullable<BABYLON.TransformNode>;
+        protected _createNode(scene: Scene): Nullable<TransformNode>;
         protected _finalProcessing(): void;
         /**
          * Creates a near menu GUI 3D control
@@ -12885,8 +12894,8 @@ declare module BABYLON.GUI {
         /**
          * Gets or sets the number of iteration to use to scatter the controls (100 by default)
          */
-        get iteration(): BABYLON.float;
-        set iteration(value: BABYLON.float);
+        get iteration(): float;
+        set iteration(value: float);
         protected _mapGridNode(control: Control3D, nodePosition: BABYLON.Vector3): void;
         private _scatterMapping;
         protected _finalProcessing(): void;
@@ -12928,7 +12937,7 @@ declare module BABYLON.GUI {
         /**
          * Gets the mesh used to render this control
          */
-        get mesh(): BABYLON.Nullable<BABYLON.AbstractMesh>;
+        get mesh(): Nullable<AbstractMesh>;
         /** Gets or sets minimum value */
         get minimum(): number;
         set minimum(value: number);
@@ -12955,8 +12964,8 @@ declare module BABYLON.GUI {
          * Gets the slider backplate material used by this control
          */
         get sliderBackplateMaterial(): MRDLBackplateMaterial;
-        protected _createNode(scene: BABYLON.Scene): BABYLON.TransformNode;
-        protected _affectMaterial(mesh: BABYLON.AbstractMesh): void;
+        protected _createNode(scene: Scene): TransformNode;
+        protected _affectMaterial(mesh: AbstractMesh): void;
         private _createBehavior;
         private _convertToPosition;
         private _convertToValue;
@@ -12975,8 +12984,8 @@ declare module BABYLON.GUI {
         /**
          * Gets or sets the radius of the sphere where to project controls (5 by default)
          */
-        get radius(): BABYLON.float;
-        set radius(value: BABYLON.float);
+        get radius(): float;
+        set radius(value: float);
         protected _mapGridNode(control: Control3D, nodePosition: BABYLON.Vector3): void;
         private _sphericalMapping;
     }
@@ -13025,7 +13034,7 @@ declare module BABYLON.GUI {
          * @param name defines the control name
          * @param collisionMesh mesh to track collisions with
          */
-        constructor(name?: string, collisionMesh?: BABYLON.Mesh);
+        constructor(name?: string, collisionMesh?: Mesh);
         /**
          * Whether the current interaction is caused by near interaction or not
          */
@@ -13043,7 +13052,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: BABYLON.Mesh);
+        set collisionMesh(collisionMesh: Mesh);
         /**
          * Setter for if this TouchButton3D should be treated as a toggle button
          * @param value If this TouchHolographicButton should act like a toggle button
@@ -13073,7 +13082,7 @@ declare module BABYLON.GUI {
          */
         _generatePointerEventType(providedType: number, nearMeshPosition: BABYLON.Vector3, activeInteractionCount: number): number;
         protected _getTypeName(): string;
-        protected _createNode(scene: BABYLON.Scene): BABYLON.TransformNode;
+        protected _createNode(scene: Scene): TransformNode;
         /**
          * Releases all associated resources
          */
@@ -13125,12 +13134,12 @@ declare module BABYLON.GUI {
         /**
          * Gets the mesh used to render this control
          */
-        get mesh(): BABYLON.Nullable<BABYLON.AbstractMesh>;
+        get mesh(): Nullable<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: BABYLON.Nullable<string>);
-        get tooltipText(): BABYLON.Nullable<string>;
+        set tooltipText(text: Nullable<string>);
+        get tooltipText(): Nullable<string>;
         /**
          * Gets or sets text for the button
          */
@@ -13169,7 +13178,7 @@ declare module BABYLON.GUI {
         constructor(name?: string, shareMaterials?: boolean);
         protected _getTypeName(): string;
         private _rebuildContent;
-        protected _createNode(scene: BABYLON.Scene): BABYLON.TransformNode;
+        protected _createNode(scene: Scene): BABYLON.TransformNode;
         protected _applyFacade(facadeTexture: AdvancedDynamicTexture): void;
         private _createBackMaterial;
         private _createFrontMaterial;
@@ -13203,9 +13212,9 @@ declare module BABYLON.GUI {
          */
         get backPlateMargin(): number;
         set backPlateMargin(value: number);
-        protected _createNode(scene: BABYLON.Scene): BABYLON.Nullable<BABYLON.TransformNode>;
-        protected _affectMaterial(mesh: BABYLON.AbstractMesh): void;
-        protected _mapGridNode(control: Control3D, nodePosition: BABYLON.Vector3): void;
+        protected _createNode(scene: Scene): Nullable<TransformNode>;
+        protected _affectMaterial(mesh: AbstractMesh): void;
+        protected _mapGridNode(control: Control3D, nodePosition: Vector3): void;
         protected _finalProcessing(): void;
         private _updateCurrentMinMax;
         private _updateMargins;
@@ -13242,16 +13251,16 @@ declare module BABYLON.GUI {
      */
     export class TouchMeshButton3D extends TouchButton3D {
         /** @hidden */
-        protected _currentMesh: BABYLON.Mesh;
+        protected _currentMesh: 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: BABYLON.Mesh, name?: string);
+        constructor(mesh: Mesh, name?: string);
         protected _getTypeName(): string;
-        protected _createNode(): BABYLON.TransformNode;
-        protected _affectMaterial(mesh: BABYLON.AbstractMesh): void;
+        protected _createNode(): TransformNode;
+        protected _affectMaterial(mesh: AbstractMesh): void;
     }
 
 
@@ -13285,14 +13294,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(): BABYLON.int;
-        set columns(value: BABYLON.int);
+        get columns(): int;
+        set columns(value: 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(): BABYLON.int;
-        set rows(value: BABYLON.int);
+        get rows(): int;
+        set rows(value: int);
         /**
          * Creates new VolumeBasedPanel
          * @param name
@@ -13327,7 +13336,7 @@ declare module BABYLON.GUI {
      * Base class for SlateGizmo handles
      */
     export abstract class GizmoHandle {
-        protected _scene: BABYLON.Scene;
+        protected _scene: Scene;
         protected _state: HandleState;
         protected _materials: HandleMaterial[];
         private _dragStartObserver;
@@ -13363,7 +13372,7 @@ declare module BABYLON.GUI {
          * @param gizmo associated SlateGizmo
          * @param scene scene
          */
-        constructor(gizmo: SlateGizmo, scene: BABYLON.Scene);
+        constructor(gizmo: SlateGizmo, scene: Scene);
         protected _createMaterial(positionOffset?: BABYLON.Vector3): HandleMaterial;
         private _updateMaterial;
         /**
@@ -13445,16 +13454,16 @@ declare module BABYLON.GUI {
         /**
          * The slate attached to this gizmo
          */
-        set attachedSlate(control: BABYLON.Nullable<HolographicSlate>);
-        get attachedSlate(): BABYLON.Nullable<HolographicSlate>;
-        constructor(utilityLayer?: BABYLON.UtilityLayerRenderer);
+        set attachedSlate(control: Nullable<HolographicSlate>);
+        get attachedSlate(): Nullable<HolographicSlate>;
+        constructor(utilityLayer?: UtilityLayerRenderer);
         private _createNode;
         private _keepAspectRatio;
         private _clampDimensions;
         private _moveHandle;
         private _assignDragBehaviorCorners;
         private _assignDragBehaviorSides;
-        protected _attachedNodeChanged(value: BABYLON.Nullable<BABYLON.AbstractMesh>): void;
+        protected _attachedNodeChanged(value: Nullable<AbstractMesh>): void;
         /**
          * Updates the bounding box information for the gizmo
          */
@@ -13470,7 +13479,7 @@ declare module BABYLON.GUI {
      * Class used to manage 3D user interface
      * @see https://doc.babylonjs.com/how_to/gui3d
      */
-    export class GUI3DManager implements BABYLON.IDisposable {
+    export class GUI3DManager implements IDisposable {
         private _scene;
         private _sceneDisposeObserver;
         private _utilityLayer;
@@ -13492,23 +13501,23 @@ declare module BABYLON.GUI {
         /**
          * BABYLON.Observable raised when the point picked by the pointer events changed
          */
-        onPickedPointChangedObservable: BABYLON.Observable<BABYLON.Nullable<BABYLON.Vector3>>;
+        onPickedPointChangedObservable: BABYLON.Observable<Nullable<BABYLON.Vector3>>;
         /**
          * BABYLON.Observable raised when a picking happens
          */
-        onPickingObservable: BABYLON.Observable<BABYLON.Nullable<BABYLON.AbstractMesh>>;
+        onPickingObservable: BABYLON.Observable<Nullable<AbstractMesh>>;
         /** @hidden */
         _sharedMaterials: {
-            [key: string]: BABYLON.Material;
+            [key: string]: Material;
         };
         /** @hidden */
         _touchSharedMaterials: {
-            [key: string]: BABYLON.Material;
+            [key: string]: Material;
         };
         /** Gets the hosting scene */
-        get scene(): BABYLON.Scene;
+        get scene(): Scene;
         /** Gets associated utility layer */
-        get utilityLayer(): BABYLON.Nullable<BABYLON.UtilityLayerRenderer>;
+        get utilityLayer(): 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 */
@@ -13521,7 +13530,7 @@ declare module BABYLON.GUI {
          * Creates a new GUI3DManager
          * @param scene
          */
-        constructor(scene?: BABYLON.Scene);
+        constructor(scene?: Scene);
         private _handlePointerOut;
         private _doPicking;
         /**
@@ -13613,25 +13622,25 @@ declare module BABYLON.GUI {
         hoverPosition: BABYLON.Vector3;
         private _albedoTexture;
         /** Gets or sets the texture to use for albedo color */
-        albedoTexture: BABYLON.Nullable<BABYLON.BaseTexture>;
+        albedoTexture: Nullable<BaseTexture>;
         /**
          * Creates a new Fluent material
          * @param name defines the name of the material
          * @param scene defines the hosting scene
          */
-        constructor(name: string, scene?: BABYLON.Scene);
+        constructor(name: string, scene?: Scene);
         needAlphaBlending(): boolean;
         needAlphaTesting(): 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;
+        getAlphaTestTexture(): Nullable<BaseTexture>;
+        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh): boolean;
+        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
+        getActiveTextures(): BaseTexture[];
+        hasTexture(texture: BaseTexture): boolean;
         dispose(forceDisposeEffect?: boolean): void;
         clone(name: string): FluentMaterial;
         serialize(): any;
         getClassName(): string;
-        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): FluentMaterial;
+        static Parse(source: any, scene: Scene, rootUrl: string): FluentMaterial;
     }
 
 
@@ -13776,22 +13785,22 @@ declare module BABYLON.GUI {
          */
         globalRightIndexTipPosition: BABYLON.Vector3;
         private _globalRightIndexTipPosition4;
-        constructor(name: string, scene?: BABYLON.Scene);
+        constructor(name: string, scene?: Scene);
         needAlphaBlending(): boolean;
         needAlphaTesting(): 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;
+        getAlphaTestTexture(): Nullable<BaseTexture>;
+        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh): boolean;
+        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
         /**
          * Get the list of animatables in the material.
          * @returns the list of animatables object used in the material
          */
-        getAnimatables(): BABYLON.IAnimatable[];
+        getAnimatables(): IAnimatable[];
         dispose(forceDisposeEffect?: boolean): void;
         clone(name: string): FluentBackplateMaterial;
         serialize(): any;
         getClassName(): string;
-        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): FluentBackplateMaterial;
+        static Parse(source: any, scene: Scene, rootUrl: string): FluentBackplateMaterial;
     }
 
 
@@ -13971,22 +13980,22 @@ declare module BABYLON.GUI {
          */
         globalRightIndexTipPosition: BABYLON.Vector3;
         private _blobTexture;
-        constructor(name: string, scene?: BABYLON.Scene);
+        constructor(name: string, scene?: Scene);
         needAlphaBlending(): boolean;
         needAlphaTesting(): 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;
+        getAlphaTestTexture(): Nullable<BaseTexture>;
+        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh): boolean;
+        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
         /**
          * Get the list of animatables in the material.
          * @returns the list of animatables object used in the material
          */
-        getAnimatables(): BABYLON.IAnimatable[];
+        getAnimatables(): IAnimatable[];
         dispose(forceDisposeEffect?: boolean): void;
         clone(name: string): FluentButtonMaterial;
         serialize(): any;
         getClassName(): string;
-        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): FluentButtonMaterial;
+        static Parse(source: any, scene: Scene, rootUrl: string): FluentButtonMaterial;
     }
 
 
@@ -14064,9 +14073,9 @@ declare module BABYLON.GUI {
         /**
          * Creates a handle material
          * @param name Name of the material
-         * @param scene BABYLON.Scene
+         * @param scene Scene
          */
-        constructor(name: string, scene: BABYLON.Scene);
+        constructor(name: string, scene: Scene);
         private _updateInterpolationTarget;
         /**
          * Disposes the handle material
@@ -14213,22 +14222,22 @@ declare module BABYLON.GUI {
          * Gets or sets the edge width of the backplate.
          */
         edgeLineGradientBlend: number;
-        constructor(name: string, scene?: BABYLON.Scene);
+        constructor(name: string, scene?: Scene);
         needAlphaBlending(): boolean;
         needAlphaTesting(): 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;
+        getAlphaTestTexture(): Nullable<BaseTexture>;
+        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh): boolean;
+        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
         /**
          * Get the list of animatables in the material.
          * @returns the list of animatables object used in the material
          */
-        getAnimatables(): BABYLON.IAnimatable[];
+        getAnimatables(): IAnimatable[];
         dispose(forceDisposeEffect?: boolean): void;
         clone(name: string): MRDLBackplateMaterial;
         serialize(): any;
         getClassName(): string;
-        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): MRDLBackplateMaterial;
+        static Parse(source: any, scene: Scene, rootUrl: string): MRDLBackplateMaterial;
     }
 
 
@@ -14535,22 +14544,22 @@ declare module BABYLON.GUI {
          * @hidden
          */
         globalRightIndexMiddlePosition: BABYLON.Vector4;
-        constructor(name: string, scene?: BABYLON.Scene);
+        constructor(name: string, scene?: Scene);
         needAlphaBlending(): boolean;
         needAlphaTesting(): 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;
+        getAlphaTestTexture(): Nullable<BaseTexture>;
+        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh): boolean;
+        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
         /**
          * Get the list of animatables in the material.
          * @returns the list of animatables object used in the material
          */
-        getAnimatables(): BABYLON.IAnimatable[];
+        getAnimatables(): IAnimatable[];
         dispose(forceDisposeEffect?: boolean): void;
         clone(name: string): MRDLSliderBarMaterial;
         serialize(): any;
         getClassName(): string;
-        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): MRDLSliderBarMaterial;
+        static Parse(source: any, scene: Scene, rootUrl: string): MRDLSliderBarMaterial;
     }
 
 
@@ -14857,22 +14866,22 @@ declare module BABYLON.GUI {
          * @hidden
          */
         globalRightIndexMiddlePosition: BABYLON.Vector4;
-        constructor(name: string, scene?: BABYLON.Scene);
+        constructor(name: string, scene?: Scene);
         needAlphaBlending(): boolean;
         needAlphaTesting(): 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;
+        getAlphaTestTexture(): Nullable<BaseTexture>;
+        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh): boolean;
+        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
         /**
          * Get the list of animatables in the material.
          * @returns the list of animatables object used in the material
          */
-        getAnimatables(): BABYLON.IAnimatable[];
+        getAnimatables(): IAnimatable[];
         dispose(forceDisposeEffect?: boolean): void;
         clone(name: string): MRDLSliderThumbMaterial;
         serialize(): any;
         getClassName(): string;
-        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): MRDLSliderThumbMaterial;
+        static Parse(source: any, scene: Scene, rootUrl: string): MRDLSliderThumbMaterial;
     }