@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/gui/2D/controls/control.d.ts

@@ -0,0 +1,748 @@
+/**
+ * Root class used for all 2D controls
+ * @see https://doc.babylonjs.com/how_to/gui#controls
+ */
+export class Control {
+    /** HORIZONTAL_ALIGNMENT_LEFT */
+    static get HORIZONTAL_ALIGNMENT_LEFT(): number;
+    /** HORIZONTAL_ALIGNMENT_RIGHT */
+    static get HORIZONTAL_ALIGNMENT_RIGHT(): number;
+    /** HORIZONTAL_ALIGNMENT_CENTER */
+    static get HORIZONTAL_ALIGNMENT_CENTER(): number;
+    /** VERTICAL_ALIGNMENT_TOP */
+    static get VERTICAL_ALIGNMENT_TOP(): number;
+    /** VERTICAL_ALIGNMENT_BOTTOM */
+    static get VERTICAL_ALIGNMENT_BOTTOM(): number;
+    /** VERTICAL_ALIGNMENT_CENTER */
+    static get VERTICAL_ALIGNMENT_CENTER(): number;
+    /**
+     * @internal
+     */
+    static _GetFontOffset(font: any): any;
+    /**
+     * Creates a Control from parsed data
+     * @param serializedObject defines parsed data
+     * @param host defines the hosting AdvancedDynamicTexture
+     * @returns a new Control
+     */
+    static Parse(serializedObject: any, host: any): any;
+    /**
+     * @internal
+     */
+    static drawEllipse(x: any, y: any, width: any, height: any, context: any): void;
+    /**
+     * Creates a new control
+     * @param name defines the name of the control
+     */
+    constructor(name: any);
+    name: any;
+    _alpha: number;
+    _alphaSet: boolean;
+    _zIndex: number;
+    /** @internal */
+    _currentMeasure: Measure;
+    /** @internal */
+    _tempPaddingMeasure: Measure;
+    _fontFamily: string;
+    _fontStyle: string;
+    _fontWeight: string;
+    _fontSize: ValueAndUnit;
+    /** @internal */
+    _width: ValueAndUnit;
+    /** @internal */
+    _height: ValueAndUnit;
+    _color: string;
+    _style: any;
+    /** @internal */
+    _horizontalAlignment: number;
+    /** @internal */
+    _verticalAlignment: number;
+    /** @internal */
+    _isDirty: boolean;
+    /** @internal */
+    _wasDirty: boolean;
+    /** @internal */
+    _tempParentMeasure: Measure;
+    /** @internal */
+    _prevCurrentMeasureTransformedIntoGlobalSpace: Measure;
+    /** @internal */
+    _cachedParentMeasure: Measure;
+    _descendantsOnlyPadding: boolean;
+    _paddingLeft: ValueAndUnit;
+    _paddingRight: ValueAndUnit;
+    _paddingTop: ValueAndUnit;
+    _paddingBottom: ValueAndUnit;
+    /** @internal */
+    _left: ValueAndUnit;
+    /** @internal */
+    _top: ValueAndUnit;
+    _scaleX: number;
+    _scaleY: number;
+    _rotation: number;
+    _transformCenterX: number;
+    _transformCenterY: number;
+    /** @internal */
+    _transformMatrix: Matrix2D;
+    /** @internal */
+    _invertTransformMatrix: Matrix2D;
+    /** @internal */
+    _transformedPosition: Vector2;
+    _isMatrixDirty: boolean;
+    _isVisible: boolean;
+    _isHighlighted: boolean;
+    _highlightColor: string;
+    _highlightLineWidth: number;
+    _fontSet: boolean;
+    _dummyVector2: Vector2;
+    _downCount: number;
+    _enterCount: number;
+    _doNotRender: boolean;
+    _downPointerIds: {};
+    _evaluatedMeasure: Measure;
+    _evaluatedParentMeasure: Measure;
+    _isEnabled: boolean;
+    _disabledColor: string;
+    _disabledColorItem: string;
+    _isReadOnly: boolean;
+    /** @internal */
+    _rebuildLayout: boolean;
+    /** @internal */
+    _customData: {};
+    /** @internal */
+    _isClipped: boolean;
+    /** @internal */
+    _automaticSize: boolean;
+    /**
+     * Gets or sets an object used to store user defined information for the node
+     */
+    metadata: any;
+    /** Gets or sets a boolean indicating if the control can be hit with pointer events */
+    isHitTestVisible: boolean;
+    /** Gets or sets a boolean indicating if the control can block pointer events. False by default except on the following controls:
+     * * Button controls (Button, RadioButton, ToggleButton)
+     * * Checkbox
+     * * ColorPicker
+     * * InputText
+     * * Slider
+     */
+    isPointerBlocker: boolean;
+    /** Gets or sets a boolean indicating if the control can be focusable */
+    isFocusInvisible: boolean;
+    /**
+     * Gets or sets a boolean indicating if the children are clipped to the current control bounds.
+     * Please note that not clipping children may generate issues with adt.useInvalidateRectOptimization so it is recommended to turn this optimization off if you want to use unclipped children
+     */
+    clipChildren: boolean;
+    /**
+     * Gets or sets a boolean indicating that control content must be clipped
+     * Please note that not clipping children may generate issues with adt.useInvalidateRectOptimization so it is recommended to turn this optimization off if you want to use unclipped children
+     */
+    clipContent: boolean;
+    /**
+     * Gets or sets a boolean indicating that the current control should cache its rendering (useful when the control does not change often)
+     */
+    useBitmapCache: boolean;
+    _shadowOffsetX: number;
+    _shadowOffsetY: number;
+    _shadowBlur: number;
+    _previousShadowBlur: number;
+    _shadowColor: string;
+    /** Gets or sets the cursor to use when the control is hovered */
+    hoverCursor: string;
+    /** @internal */
+    _linkOffsetX: ValueAndUnit;
+    /** @internal */
+    _linkOffsetY: ValueAndUnit;
+    /**
+     * An event triggered when pointer wheel is scrolled
+     */
+    onWheelObservable: Observable<any>;
+    /**
+     * An event triggered when the pointer moves over the control.
+     */
+    onPointerMoveObservable: Observable<any>;
+    /**
+     * An event triggered when the pointer moves out of the control.
+     */
+    onPointerOutObservable: Observable<any>;
+    /**
+     * An event triggered when the pointer taps the control
+     */
+    onPointerDownObservable: Observable<any>;
+    /**
+     * An event triggered when pointer up
+     */
+    onPointerUpObservable: Observable<any>;
+    /**
+     * An event triggered when a control is clicked on
+     */
+    onPointerClickObservable: Observable<any>;
+    /**
+     * An event triggered when pointer enters the control
+     */
+    onPointerEnterObservable: Observable<any>;
+    /**
+     * An event triggered when the control is marked as dirty
+     */
+    onDirtyObservable: Observable<any>;
+    /**
+     * An event triggered before drawing the control
+     */
+    onBeforeDrawObservable: Observable<any>;
+    /**
+     * An event triggered after the control was drawn
+     */
+    onAfterDrawObservable: Observable<any>;
+    /**
+     * An event triggered when the control has been disposed
+     */
+    onDisposeObservable: Observable<any>;
+    /**
+     * Gets or sets a fixed ratio for this control.
+     * When different from 0, the ratio is used to compute the "second" dimension.
+     * The first dimension used in the computation is the last one set (by setting width / widthInPixels or height / heightInPixels), and the
+     * second dimension is computed as first dimension * fixedRatio
+     */
+    fixedRatio: number;
+    _fixedRatioMasterIsWidth: boolean;
+    _tmpMeasureA: Measure;
+    set isReadOnly(arg: boolean);
+    /**
+     * Gets or sets a boolean indicating if the control is readonly (default: false).
+     * A readonly control will still raise pointer events but will not react to them
+     */
+    get isReadOnly(): boolean;
+    /**
+     * Gets the transformed measure, that is the bounding box of the control after applying all transformations
+     */
+    get transformedMeasure(): Measure;
+    set shadowOffsetX(arg: number);
+    /** Gets or sets a value indicating the offset to apply on X axis to render the shadow */
+    get shadowOffsetX(): number;
+    set shadowOffsetY(arg: number);
+    /** Gets or sets a value indicating the offset to apply on Y axis to render the shadow */
+    get shadowOffsetY(): number;
+    set shadowBlur(arg: number);
+    /** Gets or sets a value indicating the amount of blur to use to render the shadow */
+    get shadowBlur(): number;
+    set shadowColor(arg: string);
+    /** Gets or sets a value indicating the color of the shadow (black by default ie. "#000") */
+    get shadowColor(): string;
+    /** Gets the control type name */
+    get typeName(): string;
+    /**
+     * Get the current class name of the control.
+     * @returns current class name
+     */
+    getClassName(): string;
+    /**
+     * Get the hosting AdvancedDynamicTexture
+     */
+    get host(): any;
+    set fontOffset(arg: any);
+    /** Gets or set information about font offsets (used to render and align text) */
+    get fontOffset(): any;
+    _fontOffset: any;
+    set alpha(arg: number);
+    /** Gets or sets alpha value for the control (1 means opaque and 0 means entirely transparent) */
+    get alpha(): number;
+    set highlightLineWidth(arg: number);
+    /**
+     * Gets or sets a number indicating size of stroke we want to highlight the control with (mostly for debugging purpose)
+     */
+    get highlightLineWidth(): number;
+    set isHighlighted(arg: boolean);
+    /**
+     * Gets or sets a boolean indicating that we want to highlight the control (mostly for debugging purpose)
+     */
+    get isHighlighted(): boolean;
+    set highlightColor(arg: string);
+    /**
+     * Gets or sets a string defining the color to use for highlighting this control
+     */
+    get highlightColor(): string;
+    set scaleX(arg: number);
+    /** Gets or sets a value indicating the scale factor on X axis (1 by default)
+     * @see https://doc.babylonjs.com/how_to/gui#rotation-and-scaling
+     */
+    get scaleX(): number;
+    set scaleY(arg: number);
+    /** Gets or sets a value indicating the scale factor on Y axis (1 by default)
+     * @see https://doc.babylonjs.com/how_to/gui#rotation-and-scaling
+     */
+    get scaleY(): number;
+    set rotation(arg: number);
+    /** Gets or sets the rotation angle (0 by default)
+     * @see https://doc.babylonjs.com/how_to/gui#rotation-and-scaling
+     */
+    get rotation(): number;
+    set transformCenterY(arg: number);
+    /** Gets or sets the transformation center on Y axis (0 by default)
+     * @see https://doc.babylonjs.com/how_to/gui#rotation-and-scaling
+     */
+    get transformCenterY(): number;
+    set transformCenterX(arg: number);
+    /** Gets or sets the transformation center on X axis (0 by default)
+     * @see https://doc.babylonjs.com/how_to/gui#rotation-and-scaling
+     */
+    get transformCenterX(): number;
+    set horizontalAlignment(arg: number);
+    /**
+     * Gets or sets the horizontal alignment
+     * @see https://doc.babylonjs.com/how_to/gui#alignments
+     */
+    get horizontalAlignment(): number;
+    set verticalAlignment(arg: number);
+    /**
+     * Gets or sets the vertical alignment
+     * @see https://doc.babylonjs.com/how_to/gui#alignments
+     */
+    get verticalAlignment(): number;
+    set width(arg: string);
+    /**
+     * Gets or sets control width
+     * @see https://doc.babylonjs.com/how_to/gui#position-and-size
+     */
+    get width(): string;
+    set widthInPixels(arg: number);
+    /**
+     * Gets or sets the control width in pixel
+     * @see https://doc.babylonjs.com/how_to/gui#position-and-size
+     */
+    get widthInPixels(): number;
+    set height(arg: string);
+    /**
+     * Gets or sets control height
+     * @see https://doc.babylonjs.com/how_to/gui#position-and-size
+     */
+    get height(): string;
+    set heightInPixels(arg: number);
+    /**
+     * Gets or sets control height in pixel
+     * @see https://doc.babylonjs.com/how_to/gui#position-and-size
+     */
+    get heightInPixels(): number;
+    set fontFamily(arg: string);
+    /** Gets or set font family */
+    get fontFamily(): string;
+    set fontStyle(arg: string);
+    /** Gets or sets font style */
+    get fontStyle(): string;
+    set fontWeight(arg: string);
+    /** Gets or sets font weight */
+    get fontWeight(): string;
+    set style(arg: any);
+    /**
+     * Gets or sets style
+     * @see https://doc.babylonjs.com/how_to/gui#styles
+     */
+    get style(): any;
+    _styleObserver: any;
+    /** @internal */
+    get _isFontSizeInPercentage(): boolean;
+    set fontSizeInPixels(arg: any);
+    /** Gets or sets font size in pixels */
+    get fontSizeInPixels(): any;
+    set fontSize(arg: string);
+    /** Gets or sets font size */
+    get fontSize(): string;
+    set color(arg: string);
+    /** Gets or sets foreground color */
+    get color(): string;
+    set zIndex(arg: number);
+    /** Gets or sets z index which is used to reorder controls on the z axis */
+    get zIndex(): number;
+    set notRenderable(arg: boolean);
+    /** Gets or sets a boolean indicating if the control can be rendered */
+    get notRenderable(): boolean;
+    set isVisible(arg: boolean);
+    /** Gets or sets a boolean indicating if the control is visible */
+    get isVisible(): boolean;
+    /** Gets a boolean indicating that the control needs to update its rendering */
+    get isDirty(): boolean;
+    /**
+     * Gets the current linked mesh (or null if none)
+     */
+    get linkedMesh(): any;
+    set descendantsOnlyPadding(arg: boolean);
+    /**
+     * 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.
+     */
+    get descendantsOnlyPadding(): boolean;
+    set paddingLeft(arg: string);
+    /**
+     * Gets or sets a value indicating the padding to use on the left of the control
+     * @see https://doc.babylonjs.com/how_to/gui#position-and-size
+     */
+    get paddingLeft(): string;
+    set paddingLeftInPixels(arg: number);
+    /**
+     * Gets or sets a value indicating the padding in pixels to use on the left of the control
+     * @see https://doc.babylonjs.com/how_to/gui#position-and-size
+     */
+    get paddingLeftInPixels(): number;
+    /** @internal */
+    get _paddingLeftInPixels(): number;
+    set paddingRight(arg: string);
+    /**
+     * Gets or sets a value indicating the padding to use on the right of the control
+     * @see https://doc.babylonjs.com/how_to/gui#position-and-size
+     */
+    get paddingRight(): string;
+    set paddingRightInPixels(arg: number);
+    /**
+     * Gets or sets a value indicating the padding in pixels to use on the right of the control
+     * @see https://doc.babylonjs.com/how_to/gui#position-and-size
+     */
+    get paddingRightInPixels(): number;
+    /** @internal */
+    get _paddingRightInPixels(): number;
+    set paddingTop(arg: string);
+    /**
+     * Gets or sets a value indicating the padding to use on the top of the control
+     * @see https://doc.babylonjs.com/how_to/gui#position-and-size
+     */
+    get paddingTop(): string;
+    set paddingTopInPixels(arg: number);
+    /**
+     * Gets or sets a value indicating the padding in pixels to use on the top of the control
+     * @see https://doc.babylonjs.com/how_to/gui#position-and-size
+     */
+    get paddingTopInPixels(): number;
+    /** @internal */
+    get _paddingTopInPixels(): number;
+    set paddingBottom(arg: string);
+    /**
+     * Gets or sets a value indicating the padding to use on the bottom of the control
+     * @see https://doc.babylonjs.com/how_to/gui#position-and-size
+     */
+    get paddingBottom(): string;
+    set paddingBottomInPixels(arg: number);
+    /**
+     * Gets or sets a value indicating the padding in pixels to use on the bottom of the control
+     * @see https://doc.babylonjs.com/how_to/gui#position-and-size
+     */
+    get paddingBottomInPixels(): number;
+    /** @internal */
+    get _paddingBottomInPixels(): number;
+    set left(arg: string);
+    /**
+     * Gets or sets a value indicating the left coordinate of the control
+     * @see https://doc.babylonjs.com/how_to/gui#position-and-size
+     */
+    get left(): string;
+    set leftInPixels(arg: number);
+    /**
+     * Gets or sets a value indicating the left coordinate in pixels of the control
+     * @see https://doc.babylonjs.com/how_to/gui#position-and-size
+     */
+    get leftInPixels(): number;
+    set top(arg: string);
+    /**
+     * Gets or sets a value indicating the top coordinate of the control
+     * @see https://doc.babylonjs.com/how_to/gui#position-and-size
+     */
+    get top(): string;
+    set topInPixels(arg: number);
+    /**
+     * Gets or sets a value indicating the top coordinate in pixels of the control
+     * @see https://doc.babylonjs.com/how_to/gui#position-and-size
+     */
+    get topInPixels(): number;
+    set linkOffsetX(arg: string);
+    /**
+     * Gets or sets a value indicating the offset on X axis to the linked mesh
+     * @see https://doc.babylonjs.com/how_to/gui#tracking-positions
+     */
+    get linkOffsetX(): string;
+    set linkOffsetXInPixels(arg: number);
+    /**
+     * Gets or sets a value indicating the offset in pixels on X axis to the linked mesh
+     * @see https://doc.babylonjs.com/how_to/gui#tracking-positions
+     */
+    get linkOffsetXInPixels(): number;
+    set linkOffsetY(arg: string);
+    /**
+     * Gets or sets a value indicating the offset on Y axis to the linked mesh
+     * @see https://doc.babylonjs.com/how_to/gui#tracking-positions
+     */
+    get linkOffsetY(): string;
+    set linkOffsetYInPixels(arg: number);
+    /**
+     * Gets or sets a value indicating the offset in pixels on Y axis to the linked mesh
+     * @see https://doc.babylonjs.com/how_to/gui#tracking-positions
+     */
+    get linkOffsetYInPixels(): number;
+    /** Gets the center coordinate on X axis */
+    get centerX(): number;
+    /** Gets the center coordinate on Y axis */
+    get centerY(): number;
+    set isEnabled(arg: boolean);
+    /** Gets or sets if control is Enabled */
+    get isEnabled(): boolean;
+    set disabledColor(arg: string);
+    /** Gets or sets background color of control if it's disabled. Only applies to Button class. */
+    get disabledColor(): string;
+    set disabledColorItem(arg: string);
+    /** Gets or sets front color of control if it's disabled. Only applies to Checkbox class. */
+    get disabledColorItem(): string;
+    /** @internal */
+    _getTypeName(): string;
+    /**
+     * Gets the first ascendant in the hierarchy of the given type
+     * @param className defines the required type
+     * @returns the ascendant or null if not found
+     */
+    getAscendantOfClass(className: any): any;
+    /**
+     * Mark control element as dirty
+     * @param force force non visible elements to be marked too
+     */
+    markAsDirty(force?: boolean): void;
+    /**
+     * Mark the element and its children as dirty
+     */
+    markAllAsDirty(): void;
+    /** @internal */
+    _resetFontCache(): void;
+    /**
+     * Determines if a container is an ascendant of the current control
+     * @param container defines the container to look for
+     * @returns true if the container is one of the ascendant of the control
+     */
+    isAscendant(container: any): any;
+    /**
+     * Gets coordinates in local control space
+     * @param globalCoordinates defines the coordinates to transform
+     * @returns the new coordinates in local space
+     */
+    getLocalCoordinates(globalCoordinates: any): Vector2;
+    /**
+     * Gets coordinates in local control space
+     * @param globalCoordinates defines the coordinates to transform
+     * @param result defines the target vector2 where to store the result
+     * @returns the current control
+     */
+    getLocalCoordinatesToRef(globalCoordinates: any, result: any): Control;
+    /**
+     * Gets coordinates in parent local control space
+     * @param globalCoordinates defines the coordinates to transform
+     * @returns the new coordinates in parent local space
+     */
+    getParentLocalCoordinates(globalCoordinates: any): Vector2;
+    /**
+     * Move the current control to a vector3 position projected onto the screen.
+     * @param position defines the target position
+     * @param scene defines the hosting scene
+     */
+    moveToVector3(position: any, scene: any): 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
+     * @param directDescendantsOnly defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered
+     * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
+     */
+    getDescendantsToRef(results: any, directDescendantsOnly: boolean | undefined, predicate: any): void;
+    /**
+     * Will return all controls that have this control as ascendant
+     * @param directDescendantsOnly defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered
+     * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
+     * @returns all child controls
+     */
+    getDescendants(directDescendantsOnly: any, predicate: any): any[];
+    /**
+     * Link current control with a target mesh
+     * @param mesh defines the mesh to link with
+     * @see https://doc.babylonjs.com/how_to/gui#tracking-positions
+     */
+    linkWithMesh(mesh: any): void;
+    _linkedMesh: any;
+    /**
+     * 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.
+     * @param { string | number} paddingRight - The value of the right padding. If omitted, top is used.
+     * @param { string | number} paddingBottom - The value of the bottom padding. If omitted, top is used.
+     * @param { string | number} paddingLeft - The value of the left padding. If omitted, right is used.
+     * @see https://doc.babylonjs.com/how_to/gui#position-and-size
+     */
+    setPadding(paddingTop: string | number, paddingRight: string | number, paddingBottom: string | number, paddingLeft: string | number): void;
+    /**
+     * Shorthand funtion to set the top, right, bottom, and left padding values in pixels on the control.
+     * @param { number} paddingTop - The value in pixels of the top padding.
+     * @param { number} paddingRight - The value in pixels of the right padding. If omitted, top is used.
+     * @param { number} paddingBottom - The value in pixels of the bottom padding. If omitted, top is used.
+     * @param { number} paddingLeft - The value in pixels of the left padding. If omitted, right is used.
+     * @see https://doc.babylonjs.com/how_to/gui#position-and-size
+     */
+    setPaddingInPixels(paddingTop: number, paddingRight: number, paddingBottom: number, paddingLeft: number): void;
+    /**
+     * @internal
+     */
+    _moveToProjectedPosition(projectedPosition: any): void;
+    /**
+     * @internal
+     */
+    _offsetLeft(offset: any): void;
+    /**
+     * @internal
+     */
+    _offsetTop(offset: any): void;
+    /** @internal */
+    _markMatrixAsDirty(): void;
+    /** @internal */
+    _flagDescendantsAsMatrixDirty(): void;
+    /**
+     * @internal
+     */
+    _intersectsRect(rect: any, context: any): boolean;
+    /** @internal */
+    _computeAdditionnalOffsetX(): number;
+    /** @internal */
+    _computeAdditionnalOffsetY(): number;
+    /** @internal */
+    invalidateRect(): void;
+    /**
+     * @internal
+     */
+    _markAsDirty(force?: boolean): void;
+    /** @internal */
+    _markAllAsDirty(): void;
+    /**
+     * @internal
+     */
+    _link(host: any): void;
+    _host: any;
+    uniqueId: any;
+    /**
+     * @internal
+     */
+    _transform(context: any): void;
+    _cachedOffsetX: any;
+    _cachedOffsetY: any;
+    /**
+     * @internal
+     */
+    _renderHighlight(context: any): void;
+    /**
+     * @internal
+     */
+    _renderHighlightSpecific(context: any): void;
+    /**
+     * @internal
+     */
+    _applyStates(context: any): void;
+    /**
+     * @internal
+     */
+    _layout(parentMeasure: any, context: any): boolean;
+    /**
+     * @internal
+     */
+    _processMeasures(parentMeasure: any, context: any): void;
+    _evaluateClippingState(parentMeasure: any): void;
+    /** @internal */
+    _measure(): void;
+    /**
+     * @internal
+     */
+    _computeAlignment(parentMeasure: any, context: any): void;
+    /**
+     * @internal
+     */
+    _preMeasure(parentMeasure: any, context: any): void;
+    /**
+     * @internal
+     */
+    _additionalProcessing(parentMeasure: any, context: any): void;
+    /**
+     * @internal
+     */
+    _clipForChildren(context: any): void;
+    _clip(context: any, invalidatedRectangle: any): void;
+    /**
+     * @internal
+     */
+    _render(context: any, invalidatedRectangle: any): boolean;
+    _cacheData: any;
+    /**
+     * @internal
+     */
+    _draw(context: any, invalidatedRectangle: any): void;
+    /**
+     * Tests if a given coordinates belong to the current control
+     * @param x defines x coordinate to test
+     * @param y defines y coordinate to test
+     * @returns true if the coordinates are inside the control
+     */
+    contains(x: any, y: any): boolean;
+    /**
+     * @internal
+     */
+    _processPicking(x: any, y: any, pi: any, type: any, pointerId: any, buttonIndex: any, deltaX: any, deltaY: any): boolean;
+    /**
+     * @internal
+     */
+    _onPointerMove(target: any, coordinates: any, pointerId: any, pi: any): void;
+    /**
+     * @internal
+     */
+    _onPointerEnter(target: any, pi: any): boolean;
+    /**
+     * @internal
+     */
+    _onPointerOut(target: any, pi: any, force?: boolean): void;
+    /**
+     * @internal
+     */
+    _onPointerDown(target: any, coordinates: any, pointerId: any, buttonIndex: any, pi: any): boolean;
+    /**
+     * @internal
+     */
+    _onPointerUp(target: any, coordinates: any, pointerId: any, buttonIndex: any, notifyClick: any, pi: any): void;
+    /**
+     * @internal
+     */
+    _forcePointerUp(pointerId?: null): void;
+    /**
+     * @internal
+     */
+    _onWheelScroll(deltaX: any, deltaY: any): void;
+    /** @internal */
+    _onCanvasBlur(): void;
+    /**
+     * @internal
+     */
+    _processObservables(type: any, x: any, y: any, pi: any, pointerId: any, buttonIndex: any, deltaX: any, deltaY: any): boolean;
+    _prepareFont(): void;
+    _font: string | undefined;
+    /**
+     * Serializes the current control
+     * @param serializationObject defined the JSON serialized object
+     */
+    serialize(serializationObject: any): void;
+    /**
+     * @internal
+     */
+    _parseFromContent(serializedObject: any, host: any): void;
+    /** Releases associated resources */
+    dispose(): void;
+    parent: any;
+}
+export namespace Control {
+    const AllowAlphaInheritance: boolean;
+    const _ClipMeasure: Measure;
+    const _HORIZONTAL_ALIGNMENT_LEFT: number;
+    const _HORIZONTAL_ALIGNMENT_RIGHT: number;
+    const _HORIZONTAL_ALIGNMENT_CENTER: number;
+    const _VERTICAL_ALIGNMENT_TOP: number;
+    const _VERTICAL_ALIGNMENT_BOTTOM: number;
+    const _VERTICAL_ALIGNMENT_CENTER: number;
+    const _FontHeightSizes: {};
+    function AddHeader(): void;
+}
+import { Measure } from "../measure.js";
+import { ValueAndUnit } from "../valueAndUnit.js";
+import { Matrix2D } from "../math2D.js";
+import { Vector2 } from "@babylonjs/core/Maths/math.vector.js";
+import { Observable } from "@babylonjs/core/Misc/observable.js";