@combeenation/3d-viewer 0.0.1-types

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

@@ -0,0 +1,1997 @@
+/**
+ * Define how the scene should favor performance over ease of use
+ */
+export const ScenePerformancePriority: any;
+/**
+ * Represents a scene to be rendered by the engine.
+ * @see https://doc.babylonjs.com/features/scene
+ */
+export class Scene extends AbstractScene {
+    /**
+     * Factory used to create the default material.
+     * @param scene The scene to create the material for
+     * @returns The default material
+     */
+    static DefaultMaterialFactory(scene: any): void;
+    /**
+     * Factory used to create the a collision coordinator.
+     * @returns The collision coordinator
+     */
+    static CollisionCoordinatorFactory(): void;
+    static set DragMovementThreshold(arg: number);
+    /**
+     * Gets or sets the distance in pixel that you have to move to prevent some events. Default is 10 pixels
+     */
+    static get DragMovementThreshold(): number;
+    static set LongPressDelay(arg: number);
+    /**
+     * Time in milliseconds to wait to raise long press events if button is still pressed. Default is 500 ms
+     */
+    static get LongPressDelay(): number;
+    static set DoubleClickDelay(arg: number);
+    /**
+     * Time in milliseconds to wait to raise long press events if button is still pressed. Default is 300 ms
+     */
+    static get DoubleClickDelay(): number;
+    static set ExclusiveDoubleClickMode(arg: boolean);
+    /** If you need to check double click without raising a single click at first click, enable this flag */
+    static get ExclusiveDoubleClickMode(): boolean;
+    /**
+     * Creates a new Scene
+     * @param engine defines the engine to use to render this scene
+     * @param options defines the scene options
+     */
+    constructor(engine: any, options: any);
+    /** @internal */
+    _inputManager: any;
+    /** Define this parameter if you are using multiple cameras and you want to specify which one should be used for pointer position */
+    cameraToUseForPointers: any;
+    /** @internal */
+    _isScene: boolean;
+    /** @internal */
+    _blockEntityCollection: boolean;
+    /**
+     * Gets or sets a boolean that indicates if the scene must clear the render buffer before rendering a frame
+     */
+    autoClear: boolean;
+    /**
+     * Gets or sets a boolean that indicates if the scene must clear the depth and stencil buffers before rendering a frame
+     */
+    autoClearDepthAndStencil: boolean;
+    /**
+     * Defines the color used to clear the render buffer (Default is (0.2, 0.2, 0.3, 1.0))
+     */
+    clearColor: Color4;
+    /**
+     * Defines the color used to simulate the ambient color (Default is (0, 0, 0))
+     */
+    ambientColor: Color3;
+    /**
+     * Intensity of the environment in all pbr material.
+     * This dims or reinforces the IBL lighting overall (reflection and diffuse).
+     * As in the majority of the scene they are the same (exception for multi room and so on),
+     * this is easier to reference from here than from all the materials.
+     */
+    environmentIntensity: number;
+    _performancePriority: any;
+    _forceWireframe: boolean;
+    _skipFrustumClipping: boolean;
+    _forcePointsCloud: boolean;
+    /**
+     * Gets or sets a boolean indicating if animations are enabled
+     */
+    animationsEnabled: boolean;
+    _animationPropertiesOverride: any;
+    /**
+     * Gets or sets a boolean indicating if a constant deltatime has to be used
+     * This is mostly useful for testing purposes when you do not want the animations to scale with the framerate
+     */
+    useConstantAnimationDeltaTime: boolean;
+    /**
+     * Gets or sets a boolean indicating if the scene must keep the meshUnderPointer property updated
+     * Please note that it requires to run a ray cast through the scene on every frame
+     */
+    constantlyUpdateMeshUnderPointer: boolean;
+    /**
+     * Defines the HTML cursor to use when hovering over interactive elements
+     */
+    hoverCursor: string;
+    /**
+     * Defines the HTML default cursor to use (empty by default)
+     */
+    defaultCursor: string;
+    /**
+     * Defines whether cursors are handled by the scene.
+     */
+    doNotHandleCursors: boolean;
+    /**
+     * This is used to call preventDefault() on pointer down
+     * in order to block unwanted artifacts like system double clicks
+     */
+    preventDefaultOnPointerDown: boolean;
+    /**
+     * This is used to call preventDefault() on pointer up
+     * in order to block unwanted artifacts like system double clicks
+     */
+    preventDefaultOnPointerUp: boolean;
+    /**
+     * Gets or sets user defined metadata
+     */
+    metadata: any;
+    /**
+     * For internal use only. Please do not use.
+     */
+    reservedDataStore: any;
+    /**
+     * Use this array to add regular expressions used to disable offline support for specific urls
+     */
+    disableOfflineSupportExceptionRules: any[];
+    /**
+     * An event triggered when the scene is disposed.
+     */
+    onDisposeObservable: Observable<any>;
+    _onDisposeObserver: import("@babylonjs/core").Nullable<import("./Misc/observable.js").Observer<any>>;
+    /**
+     * An event triggered before rendering the scene (right after animations and physics)
+     */
+    onBeforeRenderObservable: Observable<any>;
+    _onBeforeRenderObserver: import("@babylonjs/core").Nullable<import("./Misc/observable.js").Observer<any>>;
+    /**
+     * An event triggered after rendering the scene
+     */
+    onAfterRenderObservable: Observable<any>;
+    /**
+     * An event triggered after rendering the scene for an active camera (When scene.render is called this will be called after each camera)
+     * This is triggered for each "sub" camera in a Camera Rig unlike onAfterCameraRenderObservable
+     */
+    onAfterRenderCameraObservable: Observable<any>;
+    _onAfterRenderObserver: import("@babylonjs/core").Nullable<import("./Misc/observable.js").Observer<any>>;
+    /**
+     * An event triggered before animating the scene
+     */
+    onBeforeAnimationsObservable: Observable<any>;
+    /**
+     * An event triggered after animations processing
+     */
+    onAfterAnimationsObservable: Observable<any>;
+    /**
+     * An event triggered before draw calls are ready to be sent
+     */
+    onBeforeDrawPhaseObservable: Observable<any>;
+    /**
+     * An event triggered after draw calls have been sent
+     */
+    onAfterDrawPhaseObservable: Observable<any>;
+    /**
+     * An event triggered when the scene is ready
+     */
+    onReadyObservable: Observable<any>;
+    /**
+     * An event triggered before rendering a camera
+     */
+    onBeforeCameraRenderObservable: Observable<any>;
+    _onBeforeCameraRenderObserver: import("@babylonjs/core").Nullable<import("./Misc/observable.js").Observer<any>>;
+    /**
+     * An event triggered after rendering a camera
+     * This is triggered for the full rig Camera only unlike onAfterRenderCameraObservable
+     */
+    onAfterCameraRenderObservable: Observable<any>;
+    _onAfterCameraRenderObserver: import("@babylonjs/core").Nullable<import("./Misc/observable.js").Observer<any>>;
+    /**
+     * An event triggered when active meshes evaluation is about to start
+     */
+    onBeforeActiveMeshesEvaluationObservable: Observable<any>;
+    /**
+     * An event triggered when active meshes evaluation is done
+     */
+    onAfterActiveMeshesEvaluationObservable: Observable<any>;
+    /**
+     * An event triggered when particles rendering is about to start
+     * Note: This event can be trigger more than once per frame (because particles can be rendered by render target textures as well)
+     */
+    onBeforeParticlesRenderingObservable: Observable<any>;
+    /**
+     * An event triggered when particles rendering is done
+     * Note: This event can be trigger more than once per frame (because particles can be rendered by render target textures as well)
+     */
+    onAfterParticlesRenderingObservable: Observable<any>;
+    /**
+     * An event triggered when SceneLoader.Append or SceneLoader.Load or SceneLoader.ImportMesh were successfully executed
+     */
+    onDataLoadedObservable: Observable<any>;
+    /**
+     * An event triggered when a camera is created
+     */
+    onNewCameraAddedObservable: Observable<any>;
+    /**
+     * An event triggered when a camera is removed
+     */
+    onCameraRemovedObservable: Observable<any>;
+    /**
+     * An event triggered when a light is created
+     */
+    onNewLightAddedObservable: Observable<any>;
+    /**
+     * An event triggered when a light is removed
+     */
+    onLightRemovedObservable: Observable<any>;
+    /**
+     * An event triggered when a geometry is created
+     */
+    onNewGeometryAddedObservable: Observable<any>;
+    /**
+     * An event triggered when a geometry is removed
+     */
+    onGeometryRemovedObservable: Observable<any>;
+    /**
+     * An event triggered when a transform node is created
+     */
+    onNewTransformNodeAddedObservable: Observable<any>;
+    /**
+     * An event triggered when a transform node is removed
+     */
+    onTransformNodeRemovedObservable: Observable<any>;
+    /**
+     * An event triggered when a mesh is created
+     */
+    onNewMeshAddedObservable: Observable<any>;
+    /**
+     * An event triggered when a mesh is removed
+     */
+    onMeshRemovedObservable: Observable<any>;
+    /**
+     * An event triggered when a skeleton is created
+     */
+    onNewSkeletonAddedObservable: Observable<any>;
+    /**
+     * An event triggered when a skeleton is removed
+     */
+    onSkeletonRemovedObservable: Observable<any>;
+    /**
+     * An event triggered when a material is created
+     */
+    onNewMaterialAddedObservable: Observable<any>;
+    /**
+     * An event triggered when a multi material is created
+     */
+    onNewMultiMaterialAddedObservable: Observable<any>;
+    /**
+     * An event triggered when a material is removed
+     */
+    onMaterialRemovedObservable: Observable<any>;
+    /**
+     * An event triggered when a multi material is removed
+     */
+    onMultiMaterialRemovedObservable: Observable<any>;
+    /**
+     * An event triggered when a texture is created
+     */
+    onNewTextureAddedObservable: Observable<any>;
+    /**
+     * An event triggered when a texture is removed
+     */
+    onTextureRemovedObservable: Observable<any>;
+    /**
+     * An event triggered when render targets are about to be rendered
+     * Can happen multiple times per frame.
+     */
+    onBeforeRenderTargetsRenderObservable: Observable<any>;
+    /**
+     * An event triggered when render targets were rendered.
+     * Can happen multiple times per frame.
+     */
+    onAfterRenderTargetsRenderObservable: Observable<any>;
+    /**
+     * An event triggered before calculating deterministic simulation step
+     */
+    onBeforeStepObservable: Observable<any>;
+    /**
+     * An event triggered after calculating deterministic simulation step
+     */
+    onAfterStepObservable: Observable<any>;
+    /**
+     * An event triggered when the activeCamera property is updated
+     */
+    onActiveCameraChanged: Observable<any>;
+    /**
+     * An event triggered when the activeCameras property is updated
+     */
+    onActiveCamerasChanged: Observable<any>;
+    /**
+     * This Observable will be triggered before rendering each renderingGroup of each rendered camera.
+     * The RenderingGroupInfo class contains all the information about the context in which the observable is called
+     * If you wish to register an Observer only for a given set of renderingGroup, use the mask with a combination of the renderingGroup index elevated to the power of two (1 for renderingGroup 0, 2 for renderingrOup1, 4 for 2 and 8 for 3)
+     */
+    onBeforeRenderingGroupObservable: Observable<any>;
+    /**
+     * This Observable will be triggered after rendering each renderingGroup of each rendered camera.
+     * The RenderingGroupInfo class contains all the information about the context in which the observable is called
+     * If you wish to register an Observer only for a given set of renderingGroup, use the mask with a combination of the renderingGroup index elevated to the power of two (1 for renderingGroup 0, 2 for renderingrOup1, 4 for 2 and 8 for 3)
+     */
+    onAfterRenderingGroupObservable: Observable<any>;
+    /**
+     * This Observable will when a mesh has been imported into the scene.
+     */
+    onMeshImportedObservable: Observable<any>;
+    /**
+     * This Observable will when an animation file has been imported into the scene.
+     */
+    onAnimationFileImportedObservable: Observable<any>;
+    /** @internal */
+    _registeredForLateAnimationBindings: SmartArrayNoDuplicate<any>;
+    /**
+     * Gets or sets a boolean indicating if the user want to entirely skip the picking phase when a pointer move event occurs.
+     */
+    skipPointerMovePicking: boolean;
+    /**
+     * Gets or sets a boolean indicating if the user want to entirely skip the picking phase when a pointer down event occurs.
+     */
+    skipPointerDownPicking: boolean;
+    /**
+     * Gets or sets a boolean indicating if the user want to entirely skip the picking phase when a pointer up event occurs.  Off by default.
+     */
+    skipPointerUpPicking: boolean;
+    /**
+     * This observable event is triggered when any ponter event is triggered. It is registered during Scene.attachControl() and it is called BEFORE the 3D engine process anything (mesh/sprite picking for instance).
+     * You have the possibility to skip the process and the call to onPointerObservable by setting PointerInfoPre.skipOnPointerObservable to true
+     */
+    onPrePointerObservable: Observable<any>;
+    /**
+     * Observable event triggered each time an input event is received from the rendering canvas
+     */
+    onPointerObservable: Observable<any>;
+    /**
+     * This observable event is triggered when any keyboard event si raised and registered during Scene.attachControl()
+     * You have the possibility to skip the process and the call to onKeyboardObservable by setting KeyboardInfoPre.skipOnPointerObservable to true
+     */
+    onPreKeyboardObservable: Observable<any>;
+    /**
+     * Observable event triggered each time an keyboard event is received from the hosting window
+     */
+    onKeyboardObservable: Observable<any>;
+    _useRightHandedSystem: boolean;
+    _timeAccumulator: number;
+    _currentStepId: number;
+    _currentInternalStep: number;
+    _fogEnabled: boolean;
+    _fogMode: number;
+    /**
+     * Gets or sets the fog color to use
+     * @see https://doc.babylonjs.com/babylon101/environment#fog
+     * (Default is Color3(0.2, 0.2, 0.3))
+     */
+    fogColor: Color3;
+    /**
+     * Gets or sets the fog density to use
+     * @see https://doc.babylonjs.com/babylon101/environment#fog
+     * (Default is 0.1)
+     */
+    fogDensity: number;
+    /**
+     * Gets or sets the fog start distance to use
+     * @see https://doc.babylonjs.com/babylon101/environment#fog
+     * (Default is 0)
+     */
+    fogStart: number;
+    /**
+     * Gets or sets the fog end distance to use
+     * @see https://doc.babylonjs.com/babylon101/environment#fog
+     * (Default is 1000)
+     */
+    fogEnd: number;
+    /**
+     * Flag indicating if we need to store previous matrices when rendering
+     */
+    needsPreviousWorldMatrices: boolean;
+    _shadowsEnabled: boolean;
+    _lightsEnabled: boolean;
+    _unObserveActiveCameras: (() => void) | null;
+    _texturesEnabled: boolean;
+    /**
+     * Gets or sets a boolean indicating if physic engines are enabled on this scene
+     */
+    physicsEnabled: boolean;
+    /**
+     * Gets or sets a boolean indicating if particles are enabled on this scene
+     */
+    particlesEnabled: boolean;
+    /**
+     * Gets or sets a boolean indicating if sprites are enabled on this scene
+     */
+    spritesEnabled: boolean;
+    _skeletonsEnabled: boolean;
+    /**
+     * Gets or sets a boolean indicating if lens flares are enabled on this scene
+     */
+    lensFlaresEnabled: boolean;
+    /**
+     * Gets or sets a boolean indicating if collisions are enabled on this scene
+     * @see https://doc.babylonjs.com/babylon101/cameras,_mesh_collisions_and_gravity
+     */
+    collisionsEnabled: boolean;
+    /**
+     * Defines the gravity applied to this scene (used only for collisions)
+     * @see https://doc.babylonjs.com/babylon101/cameras,_mesh_collisions_and_gravity
+     */
+    gravity: Vector3;
+    /**
+     * Gets or sets a boolean indicating if postprocesses are enabled on this scene
+     */
+    postProcessesEnabled: boolean;
+    /**
+     * Gets or sets a boolean indicating if render targets are enabled on this scene
+     */
+    renderTargetsEnabled: boolean;
+    /**
+     * Gets or sets a boolean indicating if next render targets must be dumped as image for debugging purposes
+     * We recommend not using it and instead rely on Spector.js: http://spector.babylonjs.com
+     */
+    dumpNextRenderTargets: boolean;
+    /**
+     * The list of user defined render targets added to the scene
+     */
+    customRenderTargets: any[];
+    /**
+     * Gets the list of meshes imported to the scene through SceneLoader
+     */
+    importedMeshesFiles: any[];
+    /**
+     * Gets or sets a boolean indicating if probes are enabled on this scene
+     */
+    probesEnabled: boolean;
+    _meshesForIntersections: SmartArrayNoDuplicate<any>;
+    /**
+     * Gets or sets a boolean indicating if procedural textures are enabled on this scene
+     */
+    proceduralTexturesEnabled: boolean;
+    _totalVertices: PerfCounter;
+    /** @internal */
+    _activeIndices: PerfCounter;
+    /** @internal */
+    _activeParticles: PerfCounter;
+    /** @internal */
+    _activeBones: PerfCounter;
+    /** @internal */
+    _animationTime: number;
+    /**
+     * Gets or sets a general scale for animation speed
+     * @see https://www.babylonjs-playground.com/#IBU2W7#3
+     */
+    animationTimeScale: number;
+    _renderId: number;
+    _frameId: number;
+    _executeWhenReadyTimeoutId: NodeJS.Timeout | null;
+    _intermediateRendering: boolean;
+    _defaultFrameBufferCleared: boolean;
+    _viewUpdateFlag: number;
+    _projectionUpdateFlag: number;
+    /** @internal */
+    _toBeDisposed: any[];
+    _activeRequests: any[];
+    /** @internal */
+    _pendingData: any[];
+    _isDisposed: boolean;
+    /**
+     * Gets or sets a boolean indicating that all submeshes of active meshes must be rendered
+     * Use this boolean to avoid computing frustum clipping on submeshes (This could help when you are CPU bound)
+     */
+    dispatchAllSubMeshesOfActiveMeshes: boolean;
+    _activeMeshes: SmartArray<any>;
+    _processedMaterials: SmartArray<any>;
+    _renderTargets: SmartArrayNoDuplicate<any>;
+    _materialsRenderTargets: SmartArrayNoDuplicate<any>;
+    /** @internal */
+    _activeParticleSystems: SmartArray<any>;
+    _activeSkeletons: SmartArrayNoDuplicate<any>;
+    _softwareSkinnedMeshes: SmartArrayNoDuplicate<any>;
+    /** @internal */
+    _activeAnimatables: any[];
+    _transformMatrix: Matrix;
+    /**
+     * Gets or sets a boolean indicating if lights must be sorted by priority (off by default)
+     * This is useful if there are more lights that the maximum simulteanous authorized
+     */
+    requireLightSorting: boolean;
+    /**
+     * @internal
+     * Backing store of defined scene components.
+     */
+    _components: any[];
+    /**
+     * @internal
+     * Backing store of defined scene components.
+     */
+    _serializableComponents: any[];
+    /**
+     * List of components to register on the next registration step.
+     */
+    _transientComponents: any[];
+    /**
+     * @internal
+     * Defines the actions happening before camera updates.
+     */
+    _beforeCameraUpdateStage: Stage<Function>;
+    /**
+     * @internal
+     * Defines the actions happening before clear the canvas.
+     */
+    _beforeClearStage: Stage<Function>;
+    /**
+     * @internal
+     * Defines the actions happening before clear the canvas.
+     */
+    _beforeRenderTargetClearStage: Stage<Function>;
+    /**
+     * @internal
+     * Defines the actions when collecting render targets for the frame.
+     */
+    _gatherRenderTargetsStage: Stage<Function>;
+    /**
+     * @internal
+     * Defines the actions happening for one camera in the frame.
+     */
+    _gatherActiveCameraRenderTargetsStage: Stage<Function>;
+    /**
+     * @internal
+     * Defines the actions happening during the per mesh ready checks.
+     */
+    _isReadyForMeshStage: Stage<Function>;
+    /**
+     * @internal
+     * Defines the actions happening before evaluate active mesh checks.
+     */
+    _beforeEvaluateActiveMeshStage: Stage<Function>;
+    /**
+     * @internal
+     * Defines the actions happening during the evaluate sub mesh checks.
+     */
+    _evaluateSubMeshStage: Stage<Function>;
+    /**
+     * @internal
+     * Defines the actions happening during the active mesh stage.
+     */
+    _preActiveMeshStage: Stage<Function>;
+    /**
+     * @internal
+     * Defines the actions happening during the per camera render target step.
+     */
+    _cameraDrawRenderTargetStage: Stage<Function>;
+    /**
+     * @internal
+     * Defines the actions happening just before the active camera is drawing.
+     */
+    _beforeCameraDrawStage: Stage<Function>;
+    /**
+     * @internal
+     * Defines the actions happening just before a render target is drawing.
+     */
+    _beforeRenderTargetDrawStage: Stage<Function>;
+    /**
+     * @internal
+     * Defines the actions happening just before a rendering group is drawing.
+     */
+    _beforeRenderingGroupDrawStage: Stage<Function>;
+    /**
+     * @internal
+     * Defines the actions happening just before a mesh is drawing.
+     */
+    _beforeRenderingMeshStage: Stage<Function>;
+    /**
+     * @internal
+     * Defines the actions happening just after a mesh has been drawn.
+     */
+    _afterRenderingMeshStage: Stage<Function>;
+    /**
+     * @internal
+     * Defines the actions happening just after a rendering group has been drawn.
+     */
+    _afterRenderingGroupDrawStage: Stage<Function>;
+    /**
+     * @internal
+     * Defines the actions happening just after the active camera has been drawn.
+     */
+    _afterCameraDrawStage: Stage<Function>;
+    /**
+     * @internal
+     * Defines the actions happening just after the post processing
+     */
+    _afterCameraPostProcessStage: Stage<Function>;
+    /**
+     * @internal
+     * Defines the actions happening just after a render target has been drawn.
+     */
+    _afterRenderTargetDrawStage: Stage<Function>;
+    /**
+     * Defines the actions happening just after the post processing on a render target
+     */
+    _afterRenderTargetPostProcessStage: Stage<Function>;
+    /**
+     * @internal
+     * Defines the actions happening just after rendering all cameras and computing intersections.
+     */
+    _afterRenderStage: Stage<Function>;
+    /**
+     * @internal
+     * Defines the actions happening when a pointer move event happens.
+     */
+    _pointerMoveStage: Stage<Function>;
+    /**
+     * @internal
+     * Defines the actions happening when a pointer down event happens.
+     */
+    _pointerDownStage: Stage<Function>;
+    /**
+     * @internal
+     * Defines the actions happening when a pointer up event happens.
+     */
+    _pointerUpStage: Stage<Function>;
+    /**
+     * an optional map from Geometry Id to Geometry index in the 'geometries' array
+     */
+    _geometriesByUniqueId: {} | null;
+    _defaultMeshCandidates: {
+        data: never[];
+        length: number;
+    };
+    _defaultSubMeshCandidates: {
+        data: never[];
+        length: number;
+    };
+    _preventFreeActiveMeshesAndRenderingGroups: boolean;
+    /** @internal */
+    _activeMeshesFrozen: boolean;
+    _activeMeshesFrozenButKeepClipping: boolean;
+    _skipEvaluateActiveMeshesCompletely: boolean;
+    /** @internal */
+    _allowPostProcessClearColor: boolean;
+    /**
+     * User updatable function that will return a deterministic frame time when engine is in deterministic lock step mode
+     */
+    getDeterministicFrameTime: () => any;
+    _blockMaterialDirtyMechanism: boolean;
+    /**
+     * Internal perfCollector instance used for sharing between inspector and playground.
+     * Marked as protected to allow sharing between prototype extensions, but disallow access at toplevel.
+     */
+    _perfCollector: any;
+    /**
+     * An event triggered when the cpu usage/speed meets certain thresholds.
+     * Note: Compute pressure is an experimental API.
+     */
+    onComputePressureChanged: Observable<any>;
+    set activeCameras(arg: any);
+    /** All of the active cameras added to this scene. */
+    get activeCameras(): any;
+    _engine: any;
+    _uid: string | null;
+    _renderingManager: any;
+    postProcessManager: any;
+    _imageProcessingConfiguration: ImageProcessingConfiguration | undefined;
+    useMaterialMeshMap: any;
+    useClonedMeshMap: any;
+    _computePressureObserver: ComputePressureObserverWrapper | undefined;
+    /**
+     * Texture used in all pbr material as the reflection texture.
+     * As in the majority of the scene they are the same (exception for multi room and so on),
+     * this is easier to set here than in all the materials.
+     */
+    set environmentTexture(arg: any);
+    /**
+     * Texture used in all pbr material as the reflection texture.
+     * As in the majority of the scene they are the same (exception for multi room and so on),
+     * this is easier to reference from here than from all the materials.
+     */
+    get environmentTexture(): any;
+    _environmentTexture: any;
+    /**
+     * Default image processing configuration used either in the rendering
+     * Forward main pass or through the imageProcessingPostProcess if present.
+     * As in the majority of the scene they are the same (exception for multi camera),
+     * this is easier to reference from here than from all the materials and post process.
+     *
+     * No setter as we it is a shared configuration, you can set the values instead.
+     */
+    get imageProcessingConfiguration(): ImageProcessingConfiguration | undefined;
+    set performancePriority(arg: any);
+    /**
+     * Gets or sets a value indicating how to treat performance relatively to ease of use and backward compatibility
+     */
+    get performancePriority(): any;
+    /**
+     * Gets or sets a boolean indicating if we should skip the frustum clipping part of the active meshes selection
+     */
+    set skipFrustumClipping(arg: boolean);
+    get skipFrustumClipping(): boolean;
+    /**
+     * Gets or sets a boolean indicating if all rendering must be done in wireframe
+     */
+    set forceWireframe(arg: boolean);
+    get forceWireframe(): boolean;
+    /**
+     * Gets or sets a boolean indicating if all rendering must be done in point cloud
+     */
+    set forcePointsCloud(arg: boolean);
+    get forcePointsCloud(): boolean;
+    set animationPropertiesOverride(arg: any);
+    /**
+     * Gets or sets the animation properties override
+     */
+    get animationPropertiesOverride(): any;
+    /** Sets a function to be executed when this scene is disposed. */
+    set onDispose(arg: any);
+    /** Sets a function to be executed before rendering this scene */
+    set beforeRender(arg: any);
+    /** Sets a function to be executed after rendering this scene */
+    set afterRender(arg: any);
+    /** Sets a function to be executed before rendering a camera*/
+    set beforeCameraRender(arg: any);
+    /** Sets a function to be executed after rendering a camera*/
+    set afterCameraRender(arg: any);
+    /**
+     * Gets the pointer coordinates without any translation (ie. straight out of the pointer event)
+     */
+    get unTranslatedPointer(): any;
+    /**
+     * Bind the current view position to an effect.
+     * @param effect The effect to be bound
+     * @param variableName name of the shader variable that will hold the eye position
+     * @param isVector3 true to indicates that variableName is a Vector3 and not a Vector4
+     * @returns the computed eye position
+     */
+    bindEyePosition(effect: any, variableName?: string, isVector3?: boolean): import("./Maths/math.vector.js").Vector4;
+    /**
+     * Update the scene ubo before it can be used in rendering processing
+     * @returns the scene UniformBuffer
+     */
+    finalizeSceneUbo(): any;
+    /**
+     * Gets or sets a boolean indicating if the scene must use right-handed coordinates system
+     */
+    set useRightHandedSystem(arg: boolean);
+    get useRightHandedSystem(): boolean;
+    /**
+     * Sets the step Id used by deterministic lock step
+     * @see https://doc.babylonjs.com/babylon101/animations#deterministic-lockstep
+     * @param newStepId defines the step Id
+     */
+    setStepId(newStepId: any): void;
+    /**
+     * Gets the step Id used by deterministic lock step
+     * @see https://doc.babylonjs.com/babylon101/animations#deterministic-lockstep
+     * @returns the step Id
+     */
+    getStepId(): number;
+    /**
+     * Gets the internal step used by deterministic lock step
+     * @see https://doc.babylonjs.com/babylon101/animations#deterministic-lockstep
+     * @returns the internal step
+     */
+    getInternalStep(): number;
+    /**
+     * Gets or sets a boolean indicating if fog is enabled on this scene
+     * @see https://doc.babylonjs.com/babylon101/environment#fog
+     * (Default is true)
+     */
+    set fogEnabled(arg: boolean);
+    get fogEnabled(): boolean;
+    /**
+     * Gets or sets the fog mode to use
+     * @see https://doc.babylonjs.com/babylon101/environment#fog
+     * | mode | value |
+     * | --- | --- |
+     * | FOGMODE_NONE | 0 |
+     * | FOGMODE_EXP | 1 |
+     * | FOGMODE_EXP2 | 2 |
+     * | FOGMODE_LINEAR | 3 |
+     */
+    set fogMode(arg: number);
+    get fogMode(): number;
+    /**
+     * Flag indicating that the frame buffer binding is handled by another component
+     */
+    get prePass(): boolean;
+    /**
+     * Gets or sets a boolean indicating if shadows are enabled on this scene
+     */
+    set shadowsEnabled(arg: boolean);
+    get shadowsEnabled(): boolean;
+    /**
+     * Gets or sets a boolean indicating if lights are enabled on this scene
+     */
+    set lightsEnabled(arg: boolean);
+    get lightsEnabled(): boolean;
+    _activeCameras: any;
+    set activeCamera(arg: any);
+    /** Gets or sets the current active camera */
+    get activeCamera(): any;
+    _activeCamera: any;
+    /** The default material used on meshes when no material is affected */
+    set defaultMaterial(arg: any);
+    /** The default material used on meshes when no material is affected */
+    get defaultMaterial(): any;
+    _defaultMaterial: any;
+    /**
+     * Gets or sets a boolean indicating if textures are enabled on this scene
+     */
+    set texturesEnabled(arg: boolean);
+    get texturesEnabled(): boolean;
+    /**
+     * Gets or sets a boolean indicating if skeletons are enabled on this scene
+     */
+    set skeletonsEnabled(arg: boolean);
+    get skeletonsEnabled(): boolean;
+    /** @internal */
+    get collisionCoordinator(): void;
+    _collisionCoordinator: void | undefined;
+    /**
+     * Gets the scene's rendering manager
+     */
+    get renderingManager(): any;
+    /**
+     * Gets the list of frustum planes (built from the active camera)
+     */
+    get frustumPlanes(): import("@babylonjs/core").Plane[] | undefined;
+    /**
+     * Registers the transient components if needed.
+     */
+    _registerTransientComponents(): void;
+    /**
+     * @internal
+     * Add a component to the scene.
+     * Note that the ccomponent could be registered on th next frame if this is called after
+     * the register component stage.
+     * @param component Defines the component to add to the scene
+     */
+    _addComponent(component: any): void;
+    /**
+     * @internal
+     * Gets a component from the scene.
+     * @param name defines the name of the component to retrieve
+     * @returns the component or null if not present
+     */
+    _getComponent(name: any): any;
+    /**
+     * Gets a string identifying the name of the class
+     * @returns "Scene" string
+     */
+    getClassName(): string;
+    /**
+     * @internal
+     */
+    _getDefaultMeshCandidates(): {
+        data: never[];
+        length: number;
+    };
+    /**
+     * @internal
+     */
+    _getDefaultSubMeshCandidates(mesh: any): {
+        data: never[];
+        length: number;
+    };
+    /**
+     * Sets the default candidate providers for the scene.
+     * This sets the getActiveMeshCandidates, getActiveSubMeshCandidates, getIntersectingSubMeshCandidates
+     * and getCollidingSubMeshCandidates to their default function
+     */
+    setDefaultCandidateProviders(): void;
+    getActiveMeshCandidates: (() => {
+        data: never[];
+        length: number;
+    }) | undefined;
+    getActiveSubMeshCandidates: ((mesh: any) => {
+        data: never[];
+        length: number;
+    }) | undefined;
+    getIntersectingSubMeshCandidates: ((mesh: any) => {
+        data: never[];
+        length: number;
+    }) | undefined;
+    getCollidingSubMeshCandidates: ((mesh: any) => {
+        data: never[];
+        length: number;
+    }) | undefined;
+    /**
+     * Gets the mesh that is currently under the pointer
+     */
+    get meshUnderPointer(): any;
+    set pointerX(arg: any);
+    /**
+     * Gets or sets the current on-screen X position of the pointer
+     */
+    get pointerX(): any;
+    set pointerY(arg: any);
+    /**
+     * Gets or sets the current on-screen Y position of the pointer
+     */
+    get pointerY(): any;
+    /**
+     * Gets the cached material (ie. the latest rendered one)
+     * @returns the cached material
+     */
+    getCachedMaterial(): any;
+    /**
+     * Gets the cached effect (ie. the latest rendered one)
+     * @returns the cached effect
+     */
+    getCachedEffect(): any;
+    /**
+     * Gets the cached visibility state (ie. the latest rendered one)
+     * @returns the cached visibility state
+     */
+    getCachedVisibility(): any;
+    /**
+     * Gets a boolean indicating if the current material / effect / visibility must be bind again
+     * @param material defines the current material
+     * @param effect defines the current effect
+     * @param visibility defines the current visibility state
+     * @returns true if one parameter is not cached
+     */
+    isCachedMaterialInvalid(material: any, effect: any, visibility?: number): boolean;
+    /**
+     * Gets the engine associated with the scene
+     * @returns an Engine
+     */
+    getEngine(): any;
+    /**
+     * Gets the total number of vertices rendered per frame
+     * @returns the total number of vertices rendered per frame
+     */
+    getTotalVertices(): number;
+    /**
+     * Gets the performance counter for total vertices
+     * @see https://doc.babylonjs.com/how_to/optimizing_your_scene#instrumentation
+     */
+    get totalVerticesPerfCounter(): PerfCounter;
+    /**
+     * Gets the total number of active indices rendered per frame (You can deduce the number of rendered triangles by dividing this number by 3)
+     * @returns the total number of active indices rendered per frame
+     */
+    getActiveIndices(): number;
+    /**
+     * Gets the performance counter for active indices
+     * @see https://doc.babylonjs.com/how_to/optimizing_your_scene#instrumentation
+     */
+    get totalActiveIndicesPerfCounter(): PerfCounter;
+    /**
+     * Gets the total number of active particles rendered per frame
+     * @returns the total number of active particles rendered per frame
+     */
+    getActiveParticles(): number;
+    /**
+     * Gets the performance counter for active particles
+     * @see https://doc.babylonjs.com/how_to/optimizing_your_scene#instrumentation
+     */
+    get activeParticlesPerfCounter(): PerfCounter;
+    /**
+     * Gets the total number of active bones rendered per frame
+     * @returns the total number of active bones rendered per frame
+     */
+    getActiveBones(): number;
+    /**
+     * Gets the performance counter for active bones
+     * @see https://doc.babylonjs.com/how_to/optimizing_your_scene#instrumentation
+     */
+    get activeBonesPerfCounter(): PerfCounter;
+    /**
+     * Gets the array of active meshes
+     * @returns an array of AbstractMesh
+     */
+    getActiveMeshes(): SmartArray<any>;
+    /**
+     * Gets the animation ratio (which is 1.0 is the scene renders at 60fps and 2 if the scene renders at 30fps, etc.)
+     * @returns a number
+     */
+    getAnimationRatio(): number;
+    /**
+     * Gets an unique Id for the current render phase
+     * @returns a number
+     */
+    getRenderId(): number;
+    /**
+     * Gets an unique Id for the current frame
+     * @returns a number
+     */
+    getFrameId(): number;
+    /** Call this function if you want to manually increment the render Id*/
+    incrementRenderId(): void;
+    _createUbo(): void;
+    /**
+     * Use this method to simulate a pointer move on a mesh
+     * The pickResult parameter can be obtained from a scene.pick or scene.pickWithRay
+     * @param pickResult pickingInfo of the object wished to simulate pointer event on
+     * @param pointerEventInit pointer event state to be used when simulating the pointer event (eg. pointer id for multitouch)
+     * @returns the current scene
+     */
+    simulatePointerMove(pickResult: any, pointerEventInit: any): Scene;
+    /**
+     * Use this method to simulate a pointer down on a mesh
+     * The pickResult parameter can be obtained from a scene.pick or scene.pickWithRay
+     * @param pickResult pickingInfo of the object wished to simulate pointer event on
+     * @param pointerEventInit pointer event state to be used when simulating the pointer event (eg. pointer id for multitouch)
+     * @returns the current scene
+     */
+    simulatePointerDown(pickResult: any, pointerEventInit: any): Scene;
+    /**
+     * Use this method to simulate a pointer up on a mesh
+     * The pickResult parameter can be obtained from a scene.pick or scene.pickWithRay
+     * @param pickResult pickingInfo of the object wished to simulate pointer event on
+     * @param pointerEventInit pointer event state to be used when simulating the pointer event (eg. pointer id for multitouch)
+     * @param doubleTap indicates that the pointer up event should be considered as part of a double click (false by default)
+     * @returns the current scene
+     */
+    simulatePointerUp(pickResult: any, pointerEventInit: any, doubleTap: any): Scene;
+    /**
+     * Gets a boolean indicating if the current pointer event is captured (meaning that the scene has already handled the pointer down)
+     * @param pointerId defines the pointer id to use in a multi-touch scenario (0 by default)
+     * @returns true if the pointer was captured
+     */
+    isPointerCaptured(pointerId?: number): any;
+    /**
+     * Attach events to the canvas (To handle actionManagers triggers and raise onPointerMove, onPointerDown and onPointerUp
+     * @param attachUp defines if you want to attach events to pointerup
+     * @param attachDown defines if you want to attach events to pointerdown
+     * @param attachMove defines if you want to attach events to pointermove
+     */
+    attachControl(attachUp?: boolean, attachDown?: boolean, attachMove?: boolean): void;
+    /** Detaches all event handlers*/
+    detachControl(): void;
+    /**
+     * This function will check if the scene can be rendered (textures are loaded, shaders are compiled)
+     * Delay loaded resources are not taking in account
+     * @param checkRenderTargets true to also check that the meshes rendered as part of a render target are ready (default: true)
+     * @returns true if all required resources are ready
+     */
+    isReady(checkRenderTargets?: boolean): boolean;
+    /** Resets all cached information relative to material (including effect and visibility) */
+    resetCachedMaterial(): void;
+    _cachedMaterial: any;
+    _cachedEffect: any;
+    _cachedVisibility: any;
+    /**
+     * Registers a function to be called before every frame render
+     * @param func defines the function to register
+     */
+    registerBeforeRender(func: any): void;
+    /**
+     * Unregisters a function called before every frame render
+     * @param func defines the function to unregister
+     */
+    unregisterBeforeRender(func: any): void;
+    /**
+     * Registers a function to be called after every frame render
+     * @param func defines the function to register
+     */
+    registerAfterRender(func: any): void;
+    /**
+     * Unregisters a function called after every frame render
+     * @param func defines the function to unregister
+     */
+    unregisterAfterRender(func: any): void;
+    _executeOnceBeforeRender(func: any): void;
+    /**
+     * The provided function will run before render once and will be disposed afterwards.
+     * A timeout delay can be provided so that the function will be executed in N ms.
+     * The timeout is using the browser's native setTimeout so time percision cannot be guaranteed.
+     * @param func The function to be executed.
+     * @param timeout optional delay in ms
+     */
+    executeOnceBeforeRender(func: any, timeout: any): void;
+    /**
+     * This function can help adding any object to the list of data awaited to be ready in order to check for a complete scene loading.
+     * @param data defines the object to wait for
+     */
+    addPendingData(data: any): void;
+    /**
+     * Remove a pending data from the loading list which has previously been added with addPendingData.
+     * @param data defines the object to remove from the pending list
+     */
+    removePendingData(data: any): void;
+    /**
+     * Returns the number of items waiting to be loaded
+     * @returns the number of items waiting to be loaded
+     */
+    getWaitingItemsCount(): number;
+    /**
+     * Returns a boolean indicating if the scene is still loading data
+     */
+    get isLoading(): boolean;
+    /**
+     * Registers a function to be executed when the scene is ready
+     * @param {Function} func - the function to be executed
+     * @param checkRenderTargets true to also check that the meshes rendered as part of a render target are ready (default: false)
+     */
+    executeWhenReady(func: Function, checkRenderTargets?: boolean): void;
+    /**
+     * Returns a promise that resolves when the scene is ready
+     * @param checkRenderTargets true to also check that the meshes rendered as part of a render target are ready (default: false)
+     * @returns A promise that resolves when the scene is ready
+     */
+    whenReadyAsync(checkRenderTargets?: boolean): Promise<any>;
+    /**
+     * @internal
+     */
+    _checkIsReady(checkRenderTargets?: boolean): void;
+    /**
+     * Gets all animatable attached to the scene
+     */
+    get animatables(): any[];
+    /**
+     * Resets the last animation time frame.
+     * Useful to override when animations start running when loading a scene for the first time.
+     */
+    resetLastAnimationTimeFrame(): void;
+    _animationTimeLast: number | undefined;
+    /**
+     * Gets the current view matrix
+     * @returns a Matrix
+     */
+    getViewMatrix(): any;
+    /**
+     * Gets the current projection matrix
+     * @returns a Matrix
+     */
+    getProjectionMatrix(): any;
+    /**
+     * Gets the current transform matrix
+     * @returns a Matrix made of View * Projection
+     */
+    getTransformMatrix(): Matrix;
+    /**
+     * Sets the current transform matrix
+     * @param viewL defines the View matrix to use
+     * @param projectionL defines the Projection matrix to use
+     * @param viewR defines the right View matrix to use (if provided)
+     * @param projectionR defines the right Projection matrix to use (if provided)
+     */
+    setTransformMatrix(viewL: any, projectionL: any, viewR: any, projectionR: any): void;
+    _multiviewSceneUbo: any;
+    _viewMatrix: any;
+    _projectionMatrix: any;
+    _frustumPlanes: import("@babylonjs/core").Plane[] | undefined;
+    /**
+     * Gets the uniform buffer used to store scene data
+     * @returns a UniformBuffer
+     */
+    getSceneUniformBuffer(): any;
+    /**
+     * Creates a scene UBO
+     * @param name name of the uniform buffer (optional, for debugging purpose only)
+     * @returns a new ubo
+     */
+    createSceneUniformBuffer(name: any): UniformBuffer;
+    /**
+     * Sets the scene ubo
+     * @param ubo the ubo to set for the scene
+     */
+    setSceneUniformBuffer(ubo: any): void;
+    _sceneUbo: any;
+    /**
+     * Gets an unique (relatively to the current scene) Id
+     * @returns an unique number for the scene
+     */
+    getUniqueId(): number;
+    /**
+     * Add a mesh to the list of scene's meshes
+     * @param newMesh defines the mesh to add
+     * @param recursive if all child meshes should also be added to the scene
+     */
+    addMesh(newMesh: any, recursive?: boolean): void;
+    /**
+     * Remove a mesh for the list of scene's meshes
+     * @param toRemove defines the mesh to remove
+     * @param recursive if all child meshes should also be removed from the scene
+     * @returns the index where the mesh was in the mesh list
+     */
+    removeMesh(toRemove: any, recursive?: boolean): number;
+    /**
+     * Add a transform node to the list of scene's transform nodes
+     * @param newTransformNode defines the transform node to add
+     */
+    addTransformNode(newTransformNode: any): void;
+    /**
+     * Remove a transform node for the list of scene's transform nodes
+     * @param toRemove defines the transform node to remove
+     * @returns the index where the transform node was in the transform node list
+     */
+    removeTransformNode(toRemove: any): any;
+    /**
+     * Remove a skeleton for the list of scene's skeletons
+     * @param toRemove defines the skeleton to remove
+     * @returns the index where the skeleton was in the skeleton list
+     */
+    removeSkeleton(toRemove: any): number;
+    /**
+     * Remove a morph target for the list of scene's morph targets
+     * @param toRemove defines the morph target to remove
+     * @returns the index where the morph target was in the morph target list
+     */
+    removeMorphTargetManager(toRemove: any): number;
+    /**
+     * Remove a light for the list of scene's lights
+     * @param toRemove defines the light to remove
+     * @returns the index where the light was in the light list
+     */
+    removeLight(toRemove: any): number;
+    /**
+     * Remove a camera for the list of scene's cameras
+     * @param toRemove defines the camera to remove
+     * @returns the index where the camera was in the camera list
+     */
+    removeCamera(toRemove: any): number;
+    /**
+     * Remove a particle system for the list of scene's particle systems
+     * @param toRemove defines the particle system to remove
+     * @returns the index where the particle system was in the particle system list
+     */
+    removeParticleSystem(toRemove: any): number;
+    /**
+     * Remove a animation for the list of scene's animations
+     * @param toRemove defines the animation to remove
+     * @returns the index where the animation was in the animation list
+     */
+    removeAnimation(toRemove: any): number;
+    /**
+     * Will stop the animation of the given target
+     * @param target - the target
+     * @param animationName - the name of the animation to stop (all animations will be stopped if both this and targetMask are empty)
+     * @param targetMask - a function that determines if the animation should be stopped based on its target (all animations will be stopped if both this and animationName are empty)
+     */
+    stopAnimation(target: any, animationName: any, targetMask: any): void;
+    /**
+     * Removes the given animation group from this scene.
+     * @param toRemove The animation group to remove
+     * @returns The index of the removed animation group
+     */
+    removeAnimationGroup(toRemove: any): number;
+    /**
+     * Removes the given multi-material from this scene.
+     * @param toRemove The multi-material to remove
+     * @returns The index of the removed multi-material
+     */
+    removeMultiMaterial(toRemove: any): number;
+    /**
+     * Removes the given material from this scene.
+     * @param toRemove The material to remove
+     * @returns The index of the removed material
+     */
+    removeMaterial(toRemove: any): any;
+    /**
+     * Removes the given action manager from this scene.
+     * @deprecated
+     * @param toRemove The action manager to remove
+     * @returns The index of the removed action manager
+     */
+    removeActionManager(toRemove: any): number;
+    /**
+     * Removes the given texture from this scene.
+     * @param toRemove The texture to remove
+     * @returns The index of the removed texture
+     */
+    removeTexture(toRemove: any): number;
+    /**
+     * Adds the given light to this scene
+     * @param newLight The light to add
+     */
+    addLight(newLight: any): void;
+    /**
+     * Sorts the list list based on light priorities
+     */
+    sortLightsByPriority(): void;
+    /**
+     * Adds the given camera to this scene
+     * @param newCamera The camera to add
+     */
+    addCamera(newCamera: any): void;
+    /**
+     * Adds the given skeleton to this scene
+     * @param newSkeleton The skeleton to add
+     */
+    addSkeleton(newSkeleton: any): void;
+    /**
+     * Adds the given particle system to this scene
+     * @param newParticleSystem The particle system to add
+     */
+    addParticleSystem(newParticleSystem: any): void;
+    /**
+     * Adds the given animation to this scene
+     * @param newAnimation The animation to add
+     */
+    addAnimation(newAnimation: any): void;
+    /**
+     * Adds the given animation group to this scene.
+     * @param newAnimationGroup The animation group to add
+     */
+    addAnimationGroup(newAnimationGroup: any): void;
+    /**
+     * Adds the given multi-material to this scene
+     * @param newMultiMaterial The multi-material to add
+     */
+    addMultiMaterial(newMultiMaterial: any): void;
+    /**
+     * Adds the given material to this scene
+     * @param newMaterial The material to add
+     */
+    addMaterial(newMaterial: any): void;
+    /**
+     * Adds the given morph target to this scene
+     * @param newMorphTargetManager The morph target to add
+     */
+    addMorphTargetManager(newMorphTargetManager: any): void;
+    /**
+     * Adds the given geometry to this scene
+     * @param newGeometry The geometry to add
+     */
+    addGeometry(newGeometry: any): void;
+    /**
+     * Adds the given action manager to this scene
+     * @deprecated
+     * @param newActionManager The action manager to add
+     */
+    addActionManager(newActionManager: any): void;
+    /**
+     * Adds the given texture to this scene.
+     * @param newTexture The texture to add
+     */
+    addTexture(newTexture: any): void;
+    /**
+     * Switch active camera
+     * @param newCamera defines the new active camera
+     * @param attachControl defines if attachControl must be called for the new active camera (default: true)
+     */
+    switchActiveCamera(newCamera: any, attachControl?: boolean): void;
+    /**
+     * sets the active camera of the scene using its Id
+     * @param id defines the camera's Id
+     * @returns the new active camera or null if none found.
+     */
+    setActiveCameraById(id: any): import("@babylonjs/core").Camera | null;
+    /**
+     * sets the active camera of the scene using its name
+     * @param name defines the camera's name
+     * @returns the new active camera or null if none found.
+     */
+    setActiveCameraByName(name: any): import("@babylonjs/core").Camera | null;
+    /**
+     * get an animation group using its name
+     * @param name defines the material's name
+     * @returns the animation group or null if none found.
+     */
+    getAnimationGroupByName(name: any): import("@babylonjs/core").AnimationGroup | null;
+    /**
+     * Get a material using its unique id
+     * @param uniqueId defines the material's unique id
+     * @returns the material or null if none found.
+     */
+    getMaterialByUniqueID(uniqueId: any): import("@babylonjs/core").Material | null;
+    /**
+     * get a material using its id
+     * @param id defines the material's Id
+     * @returns the material or null if none found.
+     */
+    getMaterialById(id: any): import("@babylonjs/core").Material | null;
+    /**
+     * Gets a the last added material using a given id
+     * @param id defines the material's Id
+     * @param allowMultiMaterials determines whether multimaterials should be considered
+     * @returns the last material with the given id or null if none found.
+     */
+    getLastMaterialById(id: any, allowMultiMaterials?: boolean): import("@babylonjs/core").Material | import("@babylonjs/core").MultiMaterial | null;
+    /**
+     * Gets a material using its name
+     * @param name defines the material's name
+     * @returns the material or null if none found.
+     */
+    getMaterialByName(name: any): import("@babylonjs/core").Material | null;
+    /**
+     * Get a texture using its unique id
+     * @param uniqueId defines the texture's unique id
+     * @returns the texture or null if none found.
+     */
+    getTextureByUniqueId(uniqueId: any): import("@babylonjs/core").BaseTexture | null;
+    /**
+     * Gets a texture using its name
+     * @param name defines the texture's name
+     * @returns the texture or null if none found.
+     */
+    getTextureByName(name: any): import("@babylonjs/core").BaseTexture | null;
+    /**
+     * Gets a camera using its Id
+     * @param id defines the Id to look for
+     * @returns the camera or null if not found
+     */
+    getCameraById(id: any): import("@babylonjs/core").Camera | null;
+    /**
+     * Gets a camera using its unique Id
+     * @param uniqueId defines the unique Id to look for
+     * @returns the camera or null if not found
+     */
+    getCameraByUniqueId(uniqueId: any): import("@babylonjs/core").Camera | null;
+    /**
+     * Gets a camera using its name
+     * @param name defines the camera's name
+     * @returns the camera or null if none found.
+     */
+    getCameraByName(name: any): import("@babylonjs/core").Camera | null;
+    /**
+     * Gets a bone using its Id
+     * @param id defines the bone's Id
+     * @returns the bone or null if not found
+     */
+    getBoneById(id: any): import("@babylonjs/core").Bone | null;
+    /**
+     * Gets a bone using its id
+     * @param name defines the bone's name
+     * @returns the bone or null if not found
+     */
+    getBoneByName(name: any): import("@babylonjs/core").Bone | null;
+    /**
+     * Gets a light node using its name
+     * @param name defines the the light's name
+     * @returns the light or null if none found.
+     */
+    getLightByName(name: any): import("@babylonjs/core").Light | null;
+    /**
+     * Gets a light node using its Id
+     * @param id defines the light's Id
+     * @returns the light or null if none found.
+     */
+    getLightById(id: any): import("@babylonjs/core").Light | null;
+    /**
+     * Gets a light node using its scene-generated unique Id
+     * @param uniqueId defines the light's unique Id
+     * @returns the light or null if none found.
+     */
+    getLightByUniqueId(uniqueId: any): import("@babylonjs/core").Light | null;
+    /**
+     * Gets a particle system by Id
+     * @param id defines the particle system Id
+     * @returns the corresponding system or null if none found
+     */
+    getParticleSystemById(id: any): import("@babylonjs/core").IParticleSystem | null;
+    /**
+     * Gets a geometry using its Id
+     * @param id defines the geometry's Id
+     * @returns the geometry or null if none found.
+     */
+    getGeometryById(id: any): import("@babylonjs/core").Geometry | null;
+    _getGeometryByUniqueId(uniqueId: any): import("@babylonjs/core").Geometry | null;
+    /**
+     * Add a new geometry to this scene
+     * @param geometry defines the geometry to be added to the scene.
+     * @param force defines if the geometry must be pushed even if a geometry with this id already exists
+     * @returns a boolean defining if the geometry was added or not
+     */
+    pushGeometry(geometry: any, force: any): boolean;
+    /**
+     * Removes an existing geometry
+     * @param geometry defines the geometry to be removed from the scene
+     * @returns a boolean defining if the geometry was removed or not
+     */
+    removeGeometry(geometry: any): boolean;
+    /**
+     * Gets the list of geometries attached to the scene
+     * @returns an array of Geometry
+     */
+    getGeometries(): import("@babylonjs/core").Geometry[];
+    /**
+     * Gets the first added mesh found of a given Id
+     * @param id defines the Id to search for
+     * @returns the mesh found or null if not found at all
+     */
+    getMeshById(id: any): import("@babylonjs/core").AbstractMesh | null;
+    /**
+     * Gets a list of meshes using their Id
+     * @param id defines the Id to search for
+     * @returns a list of meshes
+     */
+    getMeshesById(id: any): import("@babylonjs/core").AbstractMesh[];
+    /**
+     * Gets the first added transform node found of a given Id
+     * @param id defines the Id to search for
+     * @returns the found transform node or null if not found at all.
+     */
+    getTransformNodeById(id: any): import("@babylonjs/core").TransformNode | null;
+    /**
+     * Gets a transform node with its auto-generated unique Id
+     * @param uniqueId defines the unique Id to search for
+     * @returns the found transform node or null if not found at all.
+     */
+    getTransformNodeByUniqueId(uniqueId: any): import("@babylonjs/core").TransformNode | null;
+    /**
+     * Gets a list of transform nodes using their Id
+     * @param id defines the Id to search for
+     * @returns a list of transform nodes
+     */
+    getTransformNodesById(id: any): import("@babylonjs/core").TransformNode[];
+    /**
+     * Gets a mesh with its auto-generated unique Id
+     * @param uniqueId defines the unique Id to search for
+     * @returns the found mesh or null if not found at all.
+     */
+    getMeshByUniqueId(uniqueId: any): import("@babylonjs/core").AbstractMesh | null;
+    /**
+     * Gets a the last added mesh using a given Id
+     * @param id defines the Id to search for
+     * @returns the found mesh or null if not found at all.
+     */
+    getLastMeshById(id: any): import("@babylonjs/core").AbstractMesh | null;
+    /**
+     * Gets a the last added node (Mesh, Camera, Light) using a given Id
+     * @param id defines the Id to search for
+     * @returns the found node or null if not found at all
+     */
+    getLastEntryById(id: any): import("@babylonjs/core").TransformNode | import("@babylonjs/core").Camera | import("@babylonjs/core").Light | null;
+    /**
+     * Gets a node (Mesh, Camera, Light) using a given Id
+     * @param id defines the Id to search for
+     * @returns the found node or null if not found at all
+     */
+    getNodeById(id: any): import("@babylonjs/core").TransformNode | import("@babylonjs/core").Camera | import("@babylonjs/core").Light | import("@babylonjs/core").Bone | null;
+    /**
+     * Gets a node (Mesh, Camera, Light) using a given name
+     * @param name defines the name to search for
+     * @returns the found node or null if not found at all.
+     */
+    getNodeByName(name: any): import("@babylonjs/core").TransformNode | import("@babylonjs/core").Camera | import("@babylonjs/core").Light | import("@babylonjs/core").Bone | null;
+    /**
+     * Gets a mesh using a given name
+     * @param name defines the name to search for
+     * @returns the found mesh or null if not found at all.
+     */
+    getMeshByName(name: any): import("@babylonjs/core").AbstractMesh | null;
+    /**
+     * Gets a transform node using a given name
+     * @param name defines the name to search for
+     * @returns the found transform node or null if not found at all.
+     */
+    getTransformNodeByName(name: any): import("@babylonjs/core").TransformNode | null;
+    /**
+     * Gets a skeleton using a given Id (if many are found, this function will pick the last one)
+     * @param id defines the Id to search for
+     * @returns the found skeleton or null if not found at all.
+     */
+    getLastSkeletonById(id: any): import("@babylonjs/core").Skeleton | null;
+    /**
+     * Gets a skeleton using a given auto generated unique id
+     * @param  uniqueId defines the unique id to search for
+     * @returns the found skeleton or null if not found at all.
+     */
+    getSkeletonByUniqueId(uniqueId: any): import("@babylonjs/core").Skeleton | null;
+    /**
+     * Gets a skeleton using a given id (if many are found, this function will pick the first one)
+     * @param id defines the id to search for
+     * @returns the found skeleton or null if not found at all.
+     */
+    getSkeletonById(id: any): import("@babylonjs/core").Skeleton | null;
+    /**
+     * Gets a skeleton using a given name
+     * @param name defines the name to search for
+     * @returns the found skeleton or null if not found at all.
+     */
+    getSkeletonByName(name: any): import("@babylonjs/core").Skeleton | null;
+    /**
+     * Gets a morph target manager  using a given id (if many are found, this function will pick the last one)
+     * @param id defines the id to search for
+     * @returns the found morph target manager or null if not found at all.
+     */
+    getMorphTargetManagerById(id: any): import("@babylonjs/core").MorphTargetManager | null;
+    /**
+     * Gets a morph target using a given id (if many are found, this function will pick the first one)
+     * @param id defines the id to search for
+     * @returns the found morph target or null if not found at all.
+     */
+    getMorphTargetById(id: any): import("@babylonjs/core").MorphTarget | null;
+    /**
+     * Gets a morph target using a given name (if many are found, this function will pick the first one)
+     * @param name defines the name to search for
+     * @returns the found morph target or null if not found at all.
+     */
+    getMorphTargetByName(name: any): import("@babylonjs/core").MorphTarget | null;
+    /**
+     * Gets a post process using a given name (if many are found, this function will pick the first one)
+     * @param name defines the name to search for
+     * @returns the found post process or null if not found at all.
+     */
+    getPostProcessByName(name: any): import("@babylonjs/core").PostProcess | null;
+    /**
+     * Gets a boolean indicating if the given mesh is active
+     * @param mesh defines the mesh to look for
+     * @returns true if the mesh is in the active list
+     */
+    isActiveMesh(mesh: any): boolean;
+    /**
+     * Return a unique id as a string which can serve as an identifier for the scene
+     */
+    get uid(): string;
+    /**
+     * Add an externally attached data from its key.
+     * This method call will fail and return false, if such key already exists.
+     * If you don't care and just want to get the data no matter what, use the more convenient getOrAddExternalDataWithFactory() method.
+     * @param key the unique key that identifies the data
+     * @param data the data object to associate to the key for this Engine instance
+     * @returns true if no such key were already present and the data was added successfully, false otherwise
+     */
+    addExternalData(key: any, data: any): boolean;
+    _externalData: StringDictionary<any> | undefined;
+    /**
+     * Get an externally attached data from its key
+     * @param key the unique key that identifies the data
+     * @returns the associated data, if present (can be null), or undefined if not present
+     */
+    getExternalData(key: any): any;
+    /**
+     * Get an externally attached data from its key, create it using a factory if it's not already present
+     * @param key the unique key that identifies the data
+     * @param factory the factory that will be called to create the instance if and only if it doesn't exists
+     * @returns the associated data, can be null if the factory returned null.
+     */
+    getOrAddExternalDataWithFactory(key: any, factory: any): any;
+    /**
+     * Remove an externally attached data from the Engine instance
+     * @param key the unique key that identifies the data
+     * @returns true if the data was successfully removed, false if it doesn't exist
+     */
+    removeExternalData(key: any): boolean;
+    _evaluateSubMesh(subMesh: any, mesh: any, initialMesh: any, forcePush: any): void;
+    /**
+     * Clear the processed materials smart array preventing retention point in material dispose.
+     */
+    freeProcessedMaterials(): void;
+    set blockfreeActiveMeshesAndRenderingGroups(arg: boolean);
+    /** Gets or sets a boolean blocking all the calls to freeActiveMeshes and freeRenderingGroups
+     * It can be used in order to prevent going through methods freeRenderingGroups and freeActiveMeshes several times to improve performance
+     * when disposing several meshes in a row or a hierarchy of meshes.
+     * When used, it is the responsibility of the user to blockfreeActiveMeshesAndRenderingGroups back to false.
+     */
+    get blockfreeActiveMeshesAndRenderingGroups(): boolean;
+    /**
+     * Clear the active meshes smart array preventing retention point in mesh dispose.
+     */
+    freeActiveMeshes(): void;
+    /**
+     * Clear the info related to rendering groups preventing retention points during dispose.
+     */
+    freeRenderingGroups(): void;
+    /** @internal */
+    _isInIntermediateRendering(): boolean;
+    /**
+     * Use this function to stop evaluating active meshes. The current list will be keep alive between frames
+     * @param skipEvaluateActiveMeshes defines an optional boolean indicating that the evaluate active meshes step must be completely skipped
+     * @param onSuccess optional success callback
+     * @param onError optional error callback
+     * @param freezeMeshes defines if meshes should be frozen (true by default)
+     * @param keepFrustumCulling defines if you want to keep running the frustum clipping (false by default)
+     * @returns the current scene
+     */
+    freezeActiveMeshes(skipEvaluateActiveMeshes: boolean | undefined, onSuccess: any, onError: any, freezeMeshes?: boolean, keepFrustumCulling?: boolean): Scene;
+    /**
+     * Use this function to restart evaluating active meshes on every frame
+     * @returns the current scene
+     */
+    unfreezeActiveMeshes(): Scene;
+    _executeActiveContainerCleanup(container: any): void;
+    _evaluateActiveMeshes(): void;
+    _activeMesh(sourceMesh: any, mesh: any): void;
+    /**
+     * Update the transform matrix to update from the current active camera
+     * @param force defines a boolean used to force the update even if cache is up to date
+     */
+    updateTransformMatrix(force: any): void;
+    _bindFrameBuffer(camera: any, clear?: boolean): void;
+    _clearFrameBuffer(camera: any): void;
+    /**
+     * @internal
+     */
+    _renderForCamera(camera: any, rigParent: any, bindFrameBuffer?: boolean): void;
+    _processSubCameras(camera: any, bindFrameBuffer?: boolean): void;
+    _checkIntersections(): void;
+    /**
+     * @internal
+     */
+    _advancePhysicsEngineStep(step: any): void;
+    /** @internal */
+    _animate(): void;
+    /** Execute all animations (for a frame) */
+    animate(): void;
+    _animationRatio: number | undefined;
+    _clear(): void;
+    _checkCameraRenderTarget(camera: any): void;
+    /**
+     * Resets the draw wrappers cache of all meshes
+     * @param passId If provided, releases only the draw wrapper corresponding to this render pass id
+     */
+    resetDrawCache(passId: any): void;
+    /**
+     * Render the scene
+     * @param updateCameras defines a boolean indicating if cameras must update according to their inputs (true by default)
+     * @param ignoreAnimations defines a boolean indicating if animations should not be executed (false by default)
+     */
+    render(updateCameras?: boolean, ignoreAnimations?: boolean): void;
+    /**
+     * Freeze all materials
+     * A frozen material will not be updatable but should be faster to render
+     */
+    freezeMaterials(): void;
+    /**
+     * Unfreeze all materials
+     * A frozen material will not be updatable but should be faster to render
+     */
+    unfreezeMaterials(): void;
+    /**
+     * Releases all held resources
+     */
+    dispose(): void;
+    _disposeList(items: any, callback: any): void;
+    /**
+     * Gets if the scene is already disposed
+     */
+    get isDisposed(): boolean;
+    /**
+     * Call this function to reduce memory footprint of the scene.
+     * Vertex buffers will not store CPU data anymore (this will prevent picking, collisions or physics to work correctly)
+     */
+    clearCachedVertexData(): void;
+    /**
+     * This function will remove the local cached buffer data from texture.
+     * It will save memory but will prevent the texture from being rebuilt
+     */
+    cleanCachedTextureBuffer(): void;
+    /**
+     * Get the world extend vectors with an optional filter
+     *
+     * @param filterPredicate the predicate - which meshes should be included when calculating the world size
+     * @returns {{ min: Vector3; max: Vector3 }} min and max vectors
+     */
+    getWorldExtends(filterPredicate: any): {
+        min: Vector3;
+        max: Vector3;
+    };
+    /**
+     * Creates a ray that can be used to pick in the scene
+     * @param x defines the x coordinate of the origin (on-screen)
+     * @param y defines the y coordinate of the origin (on-screen)
+     * @param world defines the world matrix to use if you want to pick in object space (instead of world space)
+     * @param camera defines the camera to use for the picking
+     * @param cameraViewSpace defines if picking will be done in view space (false by default)
+     * @returns a Ray
+     */
+    createPickingRay(x: any, y: any, world: any, camera: any, cameraViewSpace?: boolean): void;
+    /**
+     * Creates a ray that can be used to pick in the scene
+     * @param x defines the x coordinate of the origin (on-screen)
+     * @param y defines the y coordinate of the origin (on-screen)
+     * @param world defines the world matrix to use if you want to pick in object space (instead of world space)
+     * @param result defines the ray where to store the picking ray
+     * @param camera defines the camera to use for the picking
+     * @param cameraViewSpace defines if picking will be done in view space (false by default)
+     * @param enableDistantPicking defines if picking should handle large values for mesh position/scaling (false by default)
+     * @returns the current scene
+     */
+    createPickingRayToRef(x: any, y: any, world: any, result: any, camera: any, cameraViewSpace?: boolean, enableDistantPicking?: boolean): void;
+    /**
+     * Creates a ray that can be used to pick in the scene
+     * @param x defines the x coordinate of the origin (on-screen)
+     * @param y defines the y coordinate of the origin (on-screen)
+     * @param camera defines the camera to use for the picking
+     * @returns a Ray
+     */
+    createPickingRayInCameraSpace(x: any, y: any, camera: any): void;
+    /**
+     * Creates a ray that can be used to pick in the scene
+     * @param x defines the x coordinate of the origin (on-screen)
+     * @param y defines the y coordinate of the origin (on-screen)
+     * @param result defines the ray where to store the picking ray
+     * @param camera defines the camera to use for the picking
+     * @returns the current scene
+     */
+    createPickingRayInCameraSpaceToRef(x: any, y: any, result: any, camera: any): void;
+    /** Launch a ray to try to pick a mesh in the scene
+     * @param x position on screen
+     * @param y position on screen
+     * @param predicate Predicate function used to determine eligible meshes. Can be set to null. In this case, a mesh must be enabled, visible and with isPickable set to true
+     * @param fastCheck defines if the first intersection will be used (and not the closest)
+     * @param camera to use for computing the picking ray. Can be set to null. In this case, the scene.activeCamera will be used
+     * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected
+     * @returns a PickingInfo
+     */
+    pick(x: any, y: any, predicate: any, fastCheck: any, camera: any, trianglePredicate: any): PickingInfo;
+    /** Launch a ray to try to pick a mesh in the scene using only bounding information of the main mesh (not using submeshes)
+     * @param x position on screen
+     * @param y position on screen
+     * @param predicate Predicate function used to determine eligible meshes. Can be set to null. In this case, a mesh must be enabled, visible and with isPickable set to true
+     * @param fastCheck defines if the first intersection will be used (and not the closest)
+     * @param camera to use for computing the picking ray. Can be set to null. In this case, the scene.activeCamera will be used
+     * @returns a PickingInfo (Please note that some info will not be set like distance, bv, bu and everything that cannot be capture by only using bounding infos)
+     */
+    pickWithBoundingInfo(x: any, y: any, predicate: any, fastCheck: any, camera: any): PickingInfo;
+    /** Use the given ray to pick a mesh in the scene
+     * @param ray The ray to use to pick meshes
+     * @param predicate Predicate function used to determine eligible meshes. Can be set to null. In this case, a mesh must have isPickable set to true
+     * @param fastCheck defines if the first intersection will be used (and not the closest)
+     * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected
+     * @returns a PickingInfo
+     */
+    pickWithRay(ray: any, predicate: any, fastCheck: any, trianglePredicate: any): void;
+    /**
+     * Launch a ray to try to pick a mesh in the scene
+     * @param x X position on screen
+     * @param y Y position on screen
+     * @param predicate Predicate function used to determine eligible meshes. Can be set to null. In this case, a mesh must be enabled, visible and with isPickable set to true
+     * @param camera camera to use for computing the picking ray. Can be set to null. In this case, the scene.activeCamera will be used
+     * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected
+     * @returns an array of PickingInfo
+     */
+    multiPick(x: any, y: any, predicate: any, camera: any, trianglePredicate: any): void;
+    /**
+     * Launch a ray to try to pick a mesh in the scene
+     * @param ray Ray to use
+     * @param predicate Predicate function used to determine eligible meshes. Can be set to null. In this case, a mesh must be enabled, visible and with isPickable set to true
+     * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected
+     * @returns an array of PickingInfo
+     */
+    multiPickWithRay(ray: any, predicate: any, trianglePredicate: any): void;
+    /**
+     * Force the value of meshUnderPointer
+     * @param mesh defines the mesh to use
+     * @param pointerId optional pointer id when using more than one pointer
+     * @param pickResult optional pickingInfo data used to find mesh
+     */
+    setPointerOverMesh(mesh: any, pointerId: any, pickResult: any): void;
+    /**
+     * Gets the mesh under the pointer
+     * @returns a Mesh or null if no mesh is under the pointer
+     */
+    getPointerOverMesh(): any;
+    /** @internal */
+    _rebuildGeometries(): void;
+    /** @internal */
+    _rebuildTextures(): void;
+    _getByTags(list: any, tagsQuery: any, forEach: any): any;
+    /**
+     * Get a list of meshes by tags
+     * @param tagsQuery defines the tags query to use
+     * @param forEach defines a predicate used to filter results
+     * @returns an array of Mesh
+     */
+    getMeshesByTags(tagsQuery: any, forEach: any): any;
+    /**
+     * Get a list of cameras by tags
+     * @param tagsQuery defines the tags query to use
+     * @param forEach defines a predicate used to filter results
+     * @returns an array of Camera
+     */
+    getCamerasByTags(tagsQuery: any, forEach: any): any;
+    /**
+     * Get a list of lights by tags
+     * @param tagsQuery defines the tags query to use
+     * @param forEach defines a predicate used to filter results
+     * @returns an array of Light
+     */
+    getLightsByTags(tagsQuery: any, forEach: any): any;
+    /**
+     * Get a list of materials by tags
+     * @param tagsQuery defines the tags query to use
+     * @param forEach defines a predicate used to filter results
+     * @returns an array of Material
+     */
+    getMaterialByTags(tagsQuery: any, forEach: any): any;
+    /**
+     * Get a list of transform nodes by tags
+     * @param tagsQuery defines the tags query to use
+     * @param forEach defines a predicate used to filter results
+     * @returns an array of TransformNode
+     */
+    getTransformNodesByTags(tagsQuery: any, forEach: any): any;
+    /**
+     * Overrides the default sort function applied in the rendering group to prepare the meshes.
+     * This allowed control for front to back rendering or reversly depending of the special needs.
+     *
+     * @param renderingGroupId The rendering group id corresponding to its index
+     * @param opaqueSortCompareFn The opaque queue comparison function use to sort.
+     * @param alphaTestSortCompareFn The alpha test queue comparison function use to sort.
+     * @param transparentSortCompareFn The transparent queue comparison function use to sort.
+     */
+    setRenderingOrder(renderingGroupId: any, opaqueSortCompareFn?: null, alphaTestSortCompareFn?: null, transparentSortCompareFn?: null): void;
+    /**
+     * Specifies whether or not the stencil and depth buffer are cleared between two rendering groups.
+     *
+     * @param renderingGroupId The rendering group id corresponding to its index
+     * @param autoClearDepthStencil Automatically clears depth and stencil between groups if true.
+     * @param depth Automatically clears depth between groups if true and autoClear is true.
+     * @param stencil Automatically clears stencil between groups if true and autoClear is true.
+     */
+    setRenderingAutoClearDepthStencil(renderingGroupId: any, autoClearDepthStencil: any, depth?: boolean, stencil?: boolean): void;
+    /**
+     * Gets the current auto clear configuration for one rendering group of the rendering
+     * manager.
+     * @param index the rendering group index to get the information for
+     * @returns The auto clear setup for the requested rendering group
+     */
+    getAutoClearDepthStencilSetup(index: any): any;
+    set blockMaterialDirtyMechanism(arg: boolean);
+    /** Gets or sets a boolean blocking all the calls to markAllMaterialsAsDirty (ie. the materials won't be updated if they are out of sync) */
+    get blockMaterialDirtyMechanism(): boolean;
+    /**
+     * Will flag all materials as dirty to trigger new shader compilation
+     * @param flag defines the flag used to specify which material part must be marked as dirty
+     * @param predicate If not null, it will be used to specify if a material has to be marked as dirty
+     */
+    markAllMaterialsAsDirty(flag: any, predicate: any): void;
+    /**
+     * @internal
+     */
+    _loadFile(fileOrUrl: any, onSuccess: any, onProgress: any, useOfflineSupport: any, useArrayBuffer: any, onError: any, onOpened: any): import("@babylonjs/core").IFileRequest;
+    /**
+     * @internal
+     */
+    _loadFileAsync(fileOrUrl: any, onProgress: any, useOfflineSupport: any, useArrayBuffer: any, onOpened: any): Promise<any>;
+    /**
+     * @internal
+     */
+    _requestFile(url: any, onSuccess: any, onProgress: any, useOfflineSupport: any, useArrayBuffer: any, onError: any, onOpened: any): import("@babylonjs/core").IFileRequest;
+    /**
+     * @internal
+     */
+    _requestFileAsync(url: any, onProgress: any, useOfflineSupport: any, useArrayBuffer: any, onOpened: any): Promise<any>;
+    /**
+     * @internal
+     */
+    _readFile(file: any, onSuccess: any, onProgress: any, useArrayBuffer: any, onError: any): import("@babylonjs/core").IFileRequest;
+    /**
+     * @internal
+     */
+    _readFileAsync(file: any, onProgress: any, useArrayBuffer: any): Promise<any>;
+    /**
+     * This method gets the performance collector belonging to the scene, which is generally shared with the inspector.
+     * @returns the perf collector belonging to the scene.
+     */
+    getPerfCollector(): void;
+    /**
+     * @internal
+     */
+    setActiveCameraByID(id: any): import("@babylonjs/core").Camera | null;
+    getLastMaterialByID(id: any): import("@babylonjs/core").Material | import("@babylonjs/core").MultiMaterial | null;
+    getMaterialByID(id: any): import("@babylonjs/core").Material | null;
+    getTextureByUniqueID(uniqueId: any): import("@babylonjs/core").BaseTexture | null;
+    getCameraByID(id: any): import("@babylonjs/core").Camera | null;
+    getCameraByUniqueID(uniqueId: any): import("@babylonjs/core").Camera | null;
+    getBoneByID(id: any): import("@babylonjs/core").Bone | null;
+    getLightByID(id: any): import("@babylonjs/core").Light | null;
+    getLightByUniqueID(uniqueId: any): import("@babylonjs/core").Light | null;
+    getParticleSystemByID(id: any): import("@babylonjs/core").IParticleSystem | null;
+    getGeometryByID(id: any): import("@babylonjs/core").Geometry | null;
+    getMeshByID(id: any): import("@babylonjs/core").AbstractMesh | null;
+    getMeshesByID(id: any): import("@babylonjs/core").AbstractMesh[];
+    getTransformNodeByID(id: any): import("@babylonjs/core").TransformNode | null;
+    getTransformNodeByUniqueID(uniqueId: any): import("@babylonjs/core").TransformNode | null;
+    getTransformNodesByID(id: any): import("@babylonjs/core").TransformNode[];
+    getMeshByUniqueID(uniqueId: any): import("@babylonjs/core").AbstractMesh | null;
+    getLastMeshByID(id: any): import("@babylonjs/core").AbstractMesh | null;
+    getLastEntryByID(id: any): import("@babylonjs/core").TransformNode | import("@babylonjs/core").Camera | import("@babylonjs/core").Light | null;
+    getNodeByID(id: any): import("@babylonjs/core").TransformNode | import("@babylonjs/core").Camera | import("@babylonjs/core").Light | import("@babylonjs/core").Bone | null;
+    getLastSkeletonByID(id: any): import("@babylonjs/core").Skeleton | null;
+}
+export namespace Scene {
+    const FOGMODE_NONE: number;
+    const FOGMODE_EXP: number;
+    const FOGMODE_EXP2: number;
+    const FOGMODE_LINEAR: number;
+    const MinDeltaTime: number;
+    const MaxDeltaTime: number;
+}
+import { AbstractScene } from "./abstractScene.js";
+import { Color4 } from "./Maths/math.color.js";
+import { Color3 } from "./Maths/math.color.js";
+import { Observable } from "./Misc/observable.js";
+import { SmartArrayNoDuplicate } from "./Misc/smartArray.js";
+import { Vector3 } from "./Maths/math.vector.js";
+import { PerfCounter } from "./Misc/perfCounter.js";
+import { SmartArray } from "./Misc/smartArray.js";
+import { Matrix } from "./Maths/math.vector.js";
+import { Stage } from "./sceneComponent.js";
+import { ImageProcessingConfiguration } from "./Materials/imageProcessingConfiguration.js";
+import { ComputePressureObserverWrapper } from "./Misc/computePressure.js";
+import { UniformBuffer } from "./Materials/uniformBuffer.js";
+import { StringDictionary } from "./Misc/stringDictionary.js";
+import { PickingInfo } from "./Collisions/pickingInfo.js";