@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/sceneComponent.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Groups all the scene component constants in one place to ease maintenance.
+ * @internal
+ */
+export class SceneComponentConstants {
+}
+export namespace SceneComponentConstants {
+    const NAME_EFFECTLAYER: string;
+    const NAME_LAYER: string;
+    const NAME_LENSFLARESYSTEM: string;
+    const NAME_BOUNDINGBOXRENDERER: string;
+    const NAME_PARTICLESYSTEM: string;
+    const NAME_GAMEPAD: string;
+    const NAME_SIMPLIFICATIONQUEUE: string;
+    const NAME_GEOMETRYBUFFERRENDERER: string;
+    const NAME_PREPASSRENDERER: string;
+    const NAME_DEPTHRENDERER: string;
+    const NAME_DEPTHPEELINGRENDERER: string;
+    const NAME_POSTPROCESSRENDERPIPELINEMANAGER: string;
+    const NAME_SPRITE: string;
+    const NAME_SUBSURFACE: string;
+    const NAME_OUTLINERENDERER: string;
+    const NAME_PROCEDURALTEXTURE: string;
+    const NAME_SHADOWGENERATOR: string;
+    const NAME_OCTREE: string;
+    const NAME_PHYSICSENGINE: string;
+    const NAME_AUDIO: string;
+    const STEP_ISREADYFORMESH_EFFECTLAYER: number;
+    const STEP_BEFOREEVALUATEACTIVEMESH_BOUNDINGBOXRENDERER: number;
+    const STEP_EVALUATESUBMESH_BOUNDINGBOXRENDERER: number;
+    const STEP_PREACTIVEMESH_BOUNDINGBOXRENDERER: number;
+    const STEP_CAMERADRAWRENDERTARGET_EFFECTLAYER: number;
+    const STEP_BEFORECAMERADRAW_PREPASS: number;
+    const STEP_BEFORECAMERADRAW_EFFECTLAYER: number;
+    const STEP_BEFORECAMERADRAW_LAYER: number;
+    const STEP_BEFORERENDERTARGETDRAW_PREPASS: number;
+    const STEP_BEFORERENDERTARGETDRAW_LAYER: number;
+    const STEP_BEFORERENDERINGMESH_PREPASS: number;
+    const STEP_BEFORERENDERINGMESH_OUTLINE: number;
+    const STEP_AFTERRENDERINGMESH_PREPASS: number;
+    const STEP_AFTERRENDERINGMESH_OUTLINE: number;
+    const STEP_AFTERRENDERINGGROUPDRAW_EFFECTLAYER_DRAW: number;
+    const STEP_AFTERRENDERINGGROUPDRAW_BOUNDINGBOXRENDERER: number;
+    const STEP_BEFORECAMERAUPDATE_SIMPLIFICATIONQUEUE: number;
+    const STEP_BEFORECAMERAUPDATE_GAMEPAD: number;
+    const STEP_BEFORECLEAR_PROCEDURALTEXTURE: number;
+    const STEP_BEFORECLEAR_PREPASS: number;
+    const STEP_BEFORERENDERTARGETCLEAR_PREPASS: number;
+    const STEP_AFTERRENDERTARGETDRAW_PREPASS: number;
+    const STEP_AFTERRENDERTARGETDRAW_LAYER: number;
+    const STEP_AFTERCAMERADRAW_PREPASS: number;
+    const STEP_AFTERCAMERADRAW_EFFECTLAYER: number;
+    const STEP_AFTERCAMERADRAW_LENSFLARESYSTEM: number;
+    const STEP_AFTERCAMERADRAW_EFFECTLAYER_DRAW: number;
+    const STEP_AFTERCAMERADRAW_LAYER: number;
+    const STEP_AFTERCAMERAPOSTPROCESS_LAYER: number;
+    const STEP_AFTERRENDERTARGETPOSTPROCESS_LAYER: number;
+    const STEP_AFTERRENDER_AUDIO: number;
+    const STEP_GATHERRENDERTARGETS_DEPTHRENDERER: number;
+    const STEP_GATHERRENDERTARGETS_GEOMETRYBUFFERRENDERER: number;
+    const STEP_GATHERRENDERTARGETS_SHADOWGENERATOR: number;
+    const STEP_GATHERRENDERTARGETS_POSTPROCESSRENDERPIPELINEMANAGER: number;
+    const STEP_GATHERACTIVECAMERARENDERTARGETS_DEPTHRENDERER: number;
+    const STEP_POINTERMOVE_SPRITE: number;
+    const STEP_POINTERDOWN_SPRITE: number;
+    const STEP_POINTERUP_SPRITE: number;
+}
+/**
+ * Representation of a stage in the scene (Basically a list of ordered steps)
+ * @internal
+ */
+export class Stage extends Array<any> {
+    /**
+     * Creates a new Stage.
+     * @returns A new instance of a Stage
+     */
+    static Create(): any;
+    /**
+     * Hide ctor from the rest of the world.
+     * @param items The items to add.
+     */
+    constructor(items: any);
+    /**
+     * Registers a step in an ordered way in the targeted stage.
+     * @param index Defines the position to register the step in
+     * @param component Defines the component attached to the step
+     * @param action Defines the action to launch during the step
+     */
+    registerStep(index: any, component: any, action: any): void;
+    /**
+     * Clears all the steps from the stage.
+     */
+    clear(): void;
+}

package/dist/types/node_modules/@babylonjs/core/tslib.es6.d.ts

@@ -0,0 +1,35 @@
+export function __extends(d: any, b: any): void;
+export function __rest(s: any, e: any): {};
+export function __decorate(decorators: any, target: any, key: any, desc: any, ...args: any[]): any;
+export function __param(paramIndex: any, decorator: any): (target: any, key: any) => void;
+export function __metadata(metadataKey: any, metadataValue: any): any;
+export function __awaiter(thisArg: any, _arguments: any, P: any, generator: any): any;
+export function __generator(thisArg: any, body: any): {
+    next: (v: any) => any;
+    throw: (v: any) => any;
+    return: (v: any) => any;
+};
+export function __exportStar(m: any, o: any): void;
+export function __values(o: any): any;
+export function __read(o: any, n: any): any;
+/** @deprecated */
+export function __spread(...args: any[]): any[];
+/** @deprecated */
+export function __spreadArrays(...args: any[]): any[];
+export function __spreadArray(to: any, from: any, pack: any, ...args: any[]): any;
+export function __await(v: any): __await;
+export class __await {
+    constructor(v: any);
+    v: any;
+}
+export function __asyncGenerator(thisArg: any, _arguments: any, generator: any): {};
+export function __asyncDelegator(o: any): {};
+export function __asyncValues(o: any): any;
+export function __makeTemplateObject(cooked: any, raw: any): any;
+export function __importStar(mod: any): any;
+export function __importDefault(mod: any): any;
+export function __classPrivateFieldGet(receiver: any, state: any, kind: any, f: any): any;
+export function __classPrivateFieldSet(receiver: any, state: any, value: any, kind: any, f: any): any;
+export function __classPrivateFieldIn(state: any, receiver: any): any;
+export function __assign(...args: any[]): any;
+export function __createBinding(o: any, m: any, k: any, k2: any): void;

package/dist/types/node_modules/@babylonjs/core/types.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,43 @@
+/**
+ * This class can be used to get instrumentation data from a AdvancedDynamicTexture object
+ */
+export class AdvancedDynamicTextureInstrumentation {
+    /**
+     * Instantiates a new advanced dynamic texture instrumentation.
+     * This class can be used to get instrumentation data from an AdvancedDynamicTexture object
+     * @param texture Defines the AdvancedDynamicTexture to instrument
+     */
+    constructor(texture: any);
+    texture: any;
+    _captureRenderTime: boolean;
+    _renderTime: PerfCounter;
+    _captureLayoutTime: boolean;
+    _layoutTime: PerfCounter;
+    _onBeginRenderObserver: any;
+    _onEndRenderObserver: any;
+    _onBeginLayoutObserver: any;
+    _onEndLayoutObserver: any;
+    /**
+     * Gets the perf counter used to capture render time
+     */
+    get renderTimeCounter(): PerfCounter;
+    /**
+     * Gets the perf counter used to capture layout time
+     */
+    get layoutTimeCounter(): PerfCounter;
+    set captureRenderTime(arg: boolean);
+    /**
+     * Enable or disable the render time capture
+     */
+    get captureRenderTime(): boolean;
+    set captureLayoutTime(arg: boolean);
+    /**
+     * Enable or disable the layout time capture
+     */
+    get captureLayoutTime(): boolean;
+    /**
+     * Dispose and release associated resources.
+     */
+    dispose(): void;
+}
+import { PerfCounter } from "@babylonjs/core/Misc/perfCounter.js";

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

@@ -0,0 +1,462 @@
+/**
+ * Class used to create texture to support 2D GUI elements
+ * @see https://doc.babylonjs.com/how_to/gui
+ */
+export class AdvancedDynamicTexture extends DynamicTexture {
+    /**
+     * Recreate the content of the ADT from a snippet saved by the GUI editor
+     * @param snippetId defines the snippet to load
+     * @param scaleToSize defines whether to scale to texture to the saved size
+     * @param appendToAdt if provided the snippet will be appended to the adt. Otherwise a fullscreen ADT will be created.
+     * @returns a promise that will resolve on success
+     */
+    static ParseFromSnippetAsync(snippetId: any, scaleToSize: any, appendToAdt: any): Promise<any>;
+    /**
+     * Recreate the content of the ADT from a url json
+     * @param url defines the url to load
+     * @param scaleToSize defines whether to scale to texture to the saved size
+     * @param appendToAdt if provided the snippet will be appended to the adt. Otherwise a fullscreen ADT will be created.
+     * @returns a promise that will resolve on success
+     */
+    static ParseFromFileAsync(url: any, scaleToSize: any, appendToAdt: any): Promise<any>;
+    static _LoadURLContentAsync(url: any, snippet?: boolean): Promise<any>;
+    /**
+     * Compares two rectangle based controls for pixel overlap
+     * @param control1 The first control to compare
+     * @param control2 The second control to compare
+     * @returns true if overlaps, otherwise false
+     */
+    static _Overlaps(control1: any, control2: any): boolean;
+    /**
+     * Creates a new AdvancedDynamicTexture in projected mode (ie. attached to a mesh)
+     * @param mesh defines the mesh which will receive the texture
+     * @param width defines the texture width (1024 by default)
+     * @param height defines the texture height (1024 by default)
+     * @param supportPointerMove defines a boolean indicating if the texture must capture move events (true by default)
+     * @param onlyAlphaTesting defines a boolean indicating that alpha blending will not be used (only alpha testing) (false by default)
+     * @param invertY defines if the texture needs to be inverted on the y axis during loading (true by default)
+     * @param materialSetupCallback defines a custom way of creating and setting up the material on the mesh
+     * @returns a new AdvancedDynamicTexture
+     */
+    static CreateForMesh(mesh: any, width: number | undefined, height: number | undefined, supportPointerMove: boolean | undefined, onlyAlphaTesting: boolean | undefined, invertY: any, materialSetupCallback?: typeof AdvancedDynamicTexture._CreateMaterial): AdvancedDynamicTexture;
+    static _CreateMaterial(mesh: any, uniqueId: any, texture: any, onlyAlphaTesting: any): void;
+    /**
+     * 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
+     * @param mesh defines the mesh which will receive the texture
+     * @param width defines the texture width (1024 by default)
+     * @param height defines the texture height (1024 by default)
+     * @param supportPointerMove defines a boolean indicating if the texture must capture move events (true by default)
+     * @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: any, width: number | undefined, height: number | undefined, supportPointerMove: boolean | undefined, invertY: any): AdvancedDynamicTexture;
+    /**
+     * Creates a new AdvancedDynamicTexture in fullscreen mode.
+     * In this mode the texture will rely on a layer for its rendering.
+     * This allows it to be treated like any other layer.
+     * As such, if you have a multi camera setup, you can set the layerMask on the GUI as well.
+     * LayerMask is set through advancedTexture.layer.layerMask
+     * @param name defines name for the texture
+     * @param foreground defines a boolean indicating if the texture must be rendered in foreground (default is true)
+     * @param scene defines the hosting scene
+     * @param sampling defines the texture sampling mode (Texture.BILINEAR_SAMPLINGMODE by default)
+     * @param adaptiveScaling defines whether to automatically scale root to match hardwarescaling (false by default)
+     * @returns a new AdvancedDynamicTexture
+     */
+    static CreateFullscreenUI(name: any, foreground?: boolean, scene?: null, sampling?: number, adaptiveScaling?: boolean): AdvancedDynamicTexture;
+    /**
+     * Creates a new AdvancedDynamicTexture
+     * @param name defines the name of the texture
+     * @param width defines the width of the texture
+     * @param height defines the height of the texture
+     * @param scene defines the hosting scene
+     * @param generateMipMaps defines a boolean indicating if mipmaps must be generated (false by default)
+     * @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: any, width: number | undefined, height: number | undefined, scene: any, generateMipMaps?: boolean, samplingMode?: number, invertY?: boolean);
+    _isDirty: boolean;
+    /** @internal */
+    _rootContainer: Container;
+    /** @internal */
+    _lastControlOver: {};
+    /** @internal */
+    _lastControlDown: {};
+    /** @internal */
+    _capturingControl: {};
+    /** @internal */
+    _linkedControls: any[];
+    _isFullscreen: boolean;
+    _fullscreenViewport: Viewport;
+    _idealWidth: number;
+    _idealHeight: number;
+    _useSmallestIdeal: boolean;
+    _renderAtIdealSize: boolean;
+    _blockNextFocusCheck: boolean;
+    _renderScale: number;
+    _cursorChanged: boolean;
+    _defaultMousePointerId: number;
+    /** @internal */
+    _capturedPointerIds: Set<any>;
+    /** @internal */
+    _numLayoutCalls: number;
+    /** @internal */
+    _numRenderCalls: number;
+    /**
+     * Define type to string to ensure compatibility across browsers
+     * Safari doesn't support DataTransfer constructor
+     */
+    _clipboardData: string;
+    /**
+     * Observable event triggered each time an clipboard event is received from the rendering canvas
+     */
+    onClipboardObservable: Observable<any>;
+    /**
+     * Observable event triggered each time a pointer down is intercepted by a control
+     */
+    onControlPickedObservable: Observable<any>;
+    /**
+     * Observable event triggered before layout is evaluated
+     */
+    onBeginLayoutObservable: Observable<any>;
+    /**
+     * Observable event triggered after the layout was evaluated
+     */
+    onEndLayoutObservable: Observable<any>;
+    /**
+     * Observable event triggered before the texture is rendered
+     */
+    onBeginRenderObservable: Observable<any>;
+    /**
+     * Observable event triggered after the texture was rendered
+     */
+    onEndRenderObservable: Observable<any>;
+    /**
+     * Gets or sets a boolean defining if alpha is stored as premultiplied
+     */
+    premulAlpha: boolean;
+    /**
+     * Gets or sets a boolean indicating that the canvas must be reverted on Y when updating the texture
+     */
+    applyYInversionOnUpdate: boolean;
+    /**
+     * If set to true, every scene render will trigger a pointer event for the GUI
+     * if it is linked to a mesh or has controls linked to a mesh. This will allow
+     * you to catch the pointer moving around the GUI due to camera or mesh movements,
+     * but it has a performance cost.
+     */
+    checkPointerEveryFrame: boolean;
+    _useInvalidateRectOptimization: boolean;
+    _invalidatedRectangle: Measure | null;
+    _clearMeasure: Measure;
+    /**
+     * @internal
+     */
+    _onClipboardCopy: (rawEvt: any) => void;
+    /**
+     * @internal
+     */
+    _onClipboardCut: (rawEvt: any) => void;
+    /**
+     * @internal
+     */
+    _onClipboardPaste: (rawEvt: any) => void;
+    /**
+     * Recreate the content of the ADT from a JSON object
+     * @param serializedObject define the JSON serialized object to restore from
+     * @param scaleToSize defines whether to scale to texture to the saved size
+     * @deprecated Please use parseSerializedObject instead
+     */
+    parseContent: (serializedObject: any, scaleToSize: any) => void;
+    _rootElement: any;
+    _renderObserver: any;
+    _preKeyboardObserver: any;
+    _resizeObserver: any;
+    /** Gets the number of layout calls made the last time the ADT has been rendered */
+    get numLayoutCalls(): number;
+    /** Gets the number of render calls made the last time the ADT has been rendered */
+    get numRenderCalls(): number;
+    set renderScale(arg: number);
+    /**
+     * Gets or sets a number used to scale rendering size (2 means that the texture will be twice bigger).
+     * Useful when you want more antialiasing
+     */
+    get renderScale(): number;
+    set background(arg: any);
+    /** Gets or sets the background color */
+    get background(): any;
+    _background: any;
+    set idealWidth(arg: number);
+    /**
+     * Gets or sets the ideal width used to design controls.
+     * The GUI will then rescale everything accordingly
+     * @see https://doc.babylonjs.com/how_to/gui#adaptive-scaling
+     */
+    get idealWidth(): number;
+    set idealHeight(arg: number);
+    /**
+     * Gets or sets the ideal height used to design controls.
+     * The GUI will then rescale everything accordingly
+     * @see https://doc.babylonjs.com/how_to/gui#adaptive-scaling
+     */
+    get idealHeight(): number;
+    set useSmallestIdeal(arg: boolean);
+    /**
+     * Gets or sets a boolean indicating if the smallest ideal value must be used if idealWidth and idealHeight are both set
+     * @see https://doc.babylonjs.com/how_to/gui#adaptive-scaling
+     */
+    get useSmallestIdeal(): boolean;
+    set renderAtIdealSize(arg: boolean);
+    /**
+     * Gets or sets a boolean indicating if adaptive scaling must be used
+     * @see https://doc.babylonjs.com/how_to/gui#adaptive-scaling
+     */
+    get renderAtIdealSize(): boolean;
+    /**
+     * Gets the ratio used when in "ideal mode"
+     * @see https://doc.babylonjs.com/how_to/gui#adaptive-scaling
+     * */
+    get idealRatio(): number;
+    /**
+     * Gets the underlying layer used to render the texture when in fullscreen mode
+     */
+    get layer(): any;
+    /**
+     * Gets the root container control
+     */
+    get rootContainer(): Container;
+    /**
+     * Returns an array containing the root container.
+     * This is mostly used to let the Inspector introspects the ADT
+     * @returns an array containing the rootContainer
+     */
+    getChildren(): Container[];
+    /**
+     * Will return all controls that are inside this texture
+     * @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): Control[];
+    /**
+     * Will return all controls with the given type name
+     * @param typeName defines the type name to search for
+     * @returns an array of all controls found
+     */
+    getControlsByType(typeName: any): Control[];
+    /**
+     * Will return the first control with the given name
+     * @param name defines the name to search for
+     * @returns the first control found or null
+     */
+    getControlByName(name: any): Control | null;
+    _getControlByKey(key: any, value: any): Control | null;
+    set focusedControl(arg: any);
+    /**
+     * Gets or sets the current focused control
+     */
+    get focusedControl(): any;
+    _focusedControl: any;
+    set isForeground(arg: boolean);
+    /**
+     * Gets or sets a boolean indicating if the texture must be rendered in background or foreground when in fullscreen mode
+     */
+    get isForeground(): boolean;
+    set clipboardData(arg: string);
+    /**
+     * Gets or set information about clipboardData
+     */
+    get clipboardData(): string;
+    /**
+     * Function used to execute a function on all controls
+     * @param func defines the function to execute
+     * @param container defines the container where controls belong. If null the root container will be used
+     */
+    executeOnAllControls(func: any, container: any): void;
+    set useInvalidateRectOptimization(arg: boolean);
+    /**
+     * Gets or sets a boolean indicating if the InvalidateRect optimization should be turned on
+     */
+    get useInvalidateRectOptimization(): boolean;
+    /**
+     * Invalidates a rectangle area on the gui texture
+     * @param invalidMinX left most position of the rectangle to invalidate in the texture
+     * @param invalidMinY top most position of the rectangle to invalidate in the texture
+     * @param invalidMaxX right most position of the rectangle to invalidate in the texture
+     * @param invalidMaxY bottom most position of the rectangle to invalidate in the texture
+     */
+    invalidateRect(invalidMinX: any, invalidMinY: any, invalidMaxX: any, invalidMaxY: any): void;
+    /**
+     * Marks the texture as dirty forcing a complete update
+     */
+    markAsDirty(): void;
+    /**
+     * Helper function used to create a new style
+     * @returns a new style
+     * @see https://doc.babylonjs.com/how_to/gui#styles
+     */
+    createStyle(): Style;
+    /**
+     * Adds a new control to the root container
+     * @param control defines the control to add
+     * @returns the current texture
+     */
+    addControl(control: any): AdvancedDynamicTexture;
+    /**
+     * Removes a control from the root container
+     * @param control defines the control to remove
+     * @returns the current texture
+     */
+    removeControl(control: any): AdvancedDynamicTexture;
+    /**
+     * Moves overlapped controls towards a position where it is not overlapping anymore.
+     * Please note that this method alters linkOffsetXInPixels and linkOffsetYInPixels.
+     * @param overlapGroup the overlap group which will be processed or undefined to process all overlap groups
+     * @param deltaStep the step size (speed) to reach the target non overlapping position (default 0.1)
+     * @param repelFactor how much is the control repelled by other controls
+     */
+    moveToNonOverlappedPosition(overlapGroup: any, deltaStep?: number, repelFactor?: number): void;
+    _layerToDispose: any;
+    _onResize(): void;
+    /** @internal */
+    _getGlobalViewport(): Viewport;
+    /**
+     * 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
+     */
+    getProjectedPosition(position: any, worldMatrix: any): 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: any, worldMatrix: any): Vector3;
+    _checkUpdate(camera: any): void;
+    _render(): void;
+    /**
+     * @internal
+     */
+    _changeCursor(cursor: any): void;
+    /**
+     * @internal
+     */
+    _registerLastControlDown(control: any, pointerId: any): void;
+    _doPicking(x: any, y: any, pi: any, type: any, pointerId: any, buttonIndex: any, deltaX: any, deltaY: any): void;
+    _shouldBlockPointer: boolean | undefined;
+    /**
+     * @internal
+     */
+    _cleanControlAfterRemovalFromList(list: any, control: any): void;
+    /**
+     * @internal
+     */
+    _cleanControlAfterRemoval(control: any): void;
+    /**
+     * This function will run a pointer event on this ADT and will trigger any pointer events on any controls
+     * This will work on a fullscreen ADT only. For mesh based ADT, simulate pointer events using the scene directly.
+     * @param x pointer X on the canvas for the picking
+     * @param y pointer Y on the canvas for the picking
+     * @param pi optional pointer information
+     */
+    pick(x: any, y: any, pi?: null): void;
+    _translateToPicking(scene: any, tempViewport: any, pi: any, x?: any, y?: any): void;
+    /** Attach to all scene events required to support pointer events */
+    attach(): void;
+    _prePointerObserver: import("@babylonjs/core").Nullable<import("@babylonjs/core/Misc/observable.js").Observer<import("@babylonjs/core/Events/pointerEvents.js").PointerInfoPre>> | undefined;
+    /**
+     * Register the clipboard Events onto the canvas
+     */
+    registerClipboardEvents(): void;
+    /**
+     * Unregister the clipboard Events from the canvas
+     */
+    unRegisterClipboardEvents(): void;
+    /**
+     * Transform uvs from mesh space to texture space, taking the texture into account
+     * @param uv the uvs in mesh space
+     * @returns the uvs in texture space
+     */
+    _transformUvs(uv: any): any;
+    /**
+     * Connect the texture to a hosting mesh to enable interactions
+     * @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: any, supportPointerMove?: boolean): void;
+    _pointerObserver: import("@babylonjs/core").Nullable<import("@babylonjs/core/Misc/observable.js").Observer<import("@babylonjs/core/Events/pointerEvents.js").PointerInfo>> | undefined;
+    /**
+     * Move the focus to a specific control
+     * @param control defines the control which will receive the focus
+     */
+    moveFocusToControl(control: any): void;
+    _lastPickedControl: any;
+    _manageFocus(): void;
+    _attachPickingToSceneRender(scene: any, pickFunction: any, forcePicking: any): void;
+    _sceneRenderObserver: any;
+    _attachToOnPointerOut(scene: any): void;
+    _canvasPointerOutObserver: any;
+    _attachToOnBlur(scene: any): void;
+    _canvasBlurObserver: any;
+    /**
+     * Serializes the entire GUI system
+     * @returns an object with the JSON serialized data
+     */
+    serializeContent(): {
+        root: {};
+        width: number;
+        height: number;
+    };
+    /**
+     * Recreate the content of the ADT from a JSON object
+     * @param serializedObject define the JSON serialized object to restore from
+     * @param scaleToSize defines whether to scale to texture to the saved size
+     */
+    parseSerializedObject(serializedObject: any, scaleToSize: any): void;
+    /**
+     * Clones the ADT
+     * @param newName defines the name of the new ADT
+     * @returns the clone of the ADT
+     */
+    clone(newName: any): AdvancedDynamicTexture;
+    /**
+     * Recreate the content of the ADT from a snippet saved by the GUI editor
+     * @param snippetId defines the snippet to load
+     * @param scaleToSize defines whether to scale to texture to the saved size
+     * @returns a promise that will resolve on success
+     */
+    parseFromSnippetAsync(snippetId: any, scaleToSize: any): Promise<any>;
+    /**
+     * Recreate the content of the ADT from a url json
+     * @param url defines the url to load
+     * @param scaleToSize defines whether to scale to texture to the saved size
+     * @returns a promise that will resolve on success
+     */
+    parseFromURLAsync(url: any, scaleToSize: any): Promise<any>;
+    /**
+     * Scales the texture
+     * @param ratio the scale factor to apply to both width and height
+     */
+    scale(ratio: any): void;
+    /**
+     * Resizes the texture
+     * @param width the new width
+     * @param height the new height
+     */
+    scaleTo(width: any, height: any): void;
+}
+export namespace AdvancedDynamicTexture {
+    const SnippetUrl: string;
+    const AllowGPUOptimizations: boolean;
+}
+import { DynamicTexture } from "@babylonjs/core/Materials/Textures/dynamicTexture.js";
+import { Container } from "./controls/container.js";
+import { Viewport } from "@babylonjs/core/Maths/math.viewport.js";
+import { Observable } from "@babylonjs/core/Misc/observable.js";
+import { Measure } from "./measure.js";
+import { Control } from "./controls/control.js";
+import { Style } from "./style.js";
+import { Vector2 } from "@babylonjs/core/Maths/math.vector.js";
+import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";