import { Key, ReactNode, Ref } from "react";
import { CustomProps } from "./CreatedInstance";
import { ModelProps } from "./model";
import { DynamicTerrain as ExtensionsDynamicTerrain } from "./extensions/DynamicTerrain";
import { Node as BabylonjsCoreNode } from "@babylonjs/core/node";
import { Scene as BabylonjsCoreScene } from "@babylonjs/core/scene";
import { Camera as BabylonjsCoreCamera } from "@babylonjs/core/Cameras/camera";
import { EnvironmentHelper as BabylonjsCoreEnvironmentHelper, IEnvironmentHelperOptions as BabylonjsCoreIEnvironmentHelperOptions } from "@babylonjs/core/Helpers/environmentHelper";
import { EffectLayer as BabylonjsCoreEffectLayer } from "@babylonjs/core/Layers/effectLayer";
import { Light as BabylonjsCoreLight } from "@babylonjs/core/Lights/light";
import { Material as BabylonjsCoreMaterial } from "@babylonjs/core/Materials/material";
import { Mesh as BabylonjsCoreMesh } from "@babylonjs/core/Meshes/mesh";
import { IInspectable as BabylonjsCoreIInspectable } from "@babylonjs/core/Misc/iInspectable";
import { PhysicsImpostor as BabylonjsCorePhysicsImpostor, IPhysicsEnabledObject as BabylonjsCoreIPhysicsEnabledObject, PhysicsImpostorParameters as BabylonjsCorePhysicsImpostorParameters } from "@babylonjs/core/Physics/physicsImpostor";
import { AdvancedDynamicTexture as BabylonjsGuiAdvancedDynamicTexture, IFocusableControl as BabylonjsGuiIFocusableControl } from "@babylonjs/gui/2D/advancedDynamicTexture";
import { GUI3DManager as BabylonjsGuiGUI3DManager } from "@babylonjs/gui/3D/gui3DManager";
import { AutoRotationBehavior as BabylonjsCoreAutoRotationBehavior } from "@babylonjs/core/Behaviors/Cameras/autoRotationBehavior";
import { BouncingBehavior as BabylonjsCoreBouncingBehavior } from "@babylonjs/core/Behaviors/Cameras/bouncingBehavior";
import { FramingBehavior as BabylonjsCoreFramingBehavior } from "@babylonjs/core/Behaviors/Cameras/framingBehavior";
import { AttachToBoxBehavior as BabylonjsCoreAttachToBoxBehavior } from "@babylonjs/core/Behaviors/Meshes/attachToBoxBehavior";
import { FadeInOutBehavior as BabylonjsCoreFadeInOutBehavior } from "@babylonjs/core/Behaviors/Meshes/fadeInOutBehavior";
import { MultiPointerScaleBehavior as BabylonjsCoreMultiPointerScaleBehavior } from "@babylonjs/core/Behaviors/Meshes/multiPointerScaleBehavior";
import { PointerDragBehavior as BabylonjsCorePointerDragBehavior } from "@babylonjs/core/Behaviors/Meshes/pointerDragBehavior";
import { SixDofDragBehavior as BabylonjsCoreSixDofDragBehavior } from "@babylonjs/core/Behaviors/Meshes/sixDofDragBehavior";
import { VRExperienceHelper as BabylonjsCoreVRExperienceHelper, VRExperienceHelperOptions as BabylonjsCoreVRExperienceHelperOptions } from "@babylonjs/core/Cameras/VR/vrExperienceHelper";
import { ShadowGenerator as BabylonjsCoreShadowGenerator, ICustomShaderOptions as BabylonjsCoreICustomShaderOptions } from "@babylonjs/core/Lights/Shadows/shadowGenerator";
import { BaseTexture as BabylonjsCoreBaseTexture } from "@babylonjs/core/Materials/Textures/baseTexture";
import { Control as BabylonjsGuiControl } from "@babylonjs/gui/2D/controls/control";
import { TextWrapping as BabylonjsGuiTextWrapping, TextBlock as BabylonjsGuiTextBlock } from "@babylonjs/gui/2D/controls/textBlock";
import { Control3D as BabylonjsGuiControl3D } from "@babylonjs/gui/3D/controls/control3D";
import { AnimationPropertiesOverride as BabylonjsCoreAnimationPropertiesOverride } from "@babylonjs/core/Animations/animationPropertiesOverride";
import { Animation as BabylonjsCoreAnimation } from "@babylonjs/core/Animations/animation";
import { Observable as BabylonjsCoreObservable } from "@babylonjs/core/Misc/observable";
import { TransformNode as BabylonjsCoreTransformNode } from "@babylonjs/core/Meshes/transformNode";
import { Vector3 as BabylonjsCoreVector3, Quaternion as BabylonjsCoreQuaternion, Matrix as BabylonjsCoreMatrix, Vector2 as BabylonjsCoreVector2, Vector4 as BabylonjsCoreVector4 } from "@babylonjs/core/Maths/math.vector";
import { FloatArray as BabylonjsCoreFloatArray } from "@babylonjs/core/types";
import { AbstractMesh as BabylonjsCoreAbstractMesh } from "@babylonjs/core/Meshes/abstractMesh";
import { AbstractActionManager as BabylonjsCoreAbstractActionManager } from "@babylonjs/core/Actions/abstractActionManager";
import { Color4 as BabylonjsCoreColor4, Color3 as BabylonjsCoreColor3 } from "@babylonjs/core/Maths/math.color";
import { Skeleton as BabylonjsCoreSkeleton } from "@babylonjs/core/Bones/skeleton";
import { SubMesh as BabylonjsCoreSubMesh } from "@babylonjs/core/Meshes/subMesh";
import { InstancedMesh as BabylonjsCoreInstancedMesh } from "@babylonjs/core/Meshes/instancedMesh";
import { MorphTargetManager as BabylonjsCoreMorphTargetManager } from "@babylonjs/core/Morph/morphTargetManager";
import { RenderTargetTexture as BabylonjsCoreRenderTargetTexture } from "@babylonjs/core/Materials/Textures/renderTargetTexture";
import { CameraInputsManager as BabylonjsCoreCameraInputsManager } from "@babylonjs/core/Cameras/cameraInputsManager";
import { Viewport as BabylonjsCoreViewport } from "@babylonjs/core/Maths/math.viewport";
import { TargetCamera as BabylonjsCoreTargetCamera } from "@babylonjs/core/Cameras/targetCamera";
import { FreeCamera as BabylonjsCoreFreeCamera } from "@babylonjs/core/Cameras/freeCamera";
import { FreeCameraInputsManager as BabylonjsCoreFreeCameraInputsManager } from "@babylonjs/core/Cameras/freeCameraInputsManager";
import { TouchCamera as BabylonjsCoreTouchCamera } from "@babylonjs/core/Cameras/touchCamera";
import { UniversalCamera as BabylonjsCoreUniversalCamera } from "@babylonjs/core/Cameras/universalCamera";
import { GamepadCamera as BabylonjsCoreGamepadCamera } from "@babylonjs/core/Cameras/gamepadCamera";
import { AnaglyphGamepadCamera as BabylonjsCoreAnaglyphGamepadCamera } from "@babylonjs/core/Cameras/Stereoscopic/anaglyphGamepadCamera";
import { StereoscopicGamepadCamera as BabylonjsCoreStereoscopicGamepadCamera } from "@babylonjs/core/Cameras/Stereoscopic/stereoscopicGamepadCamera";
import { AnaglyphUniversalCamera as BabylonjsCoreAnaglyphUniversalCamera } from "@babylonjs/core/Cameras/Stereoscopic/anaglyphUniversalCamera";
import { StereoscopicUniversalCamera as BabylonjsCoreStereoscopicUniversalCamera } from "@babylonjs/core/Cameras/Stereoscopic/stereoscopicUniversalCamera";
import { DeviceOrientationCamera as BabylonjsCoreDeviceOrientationCamera } from "@babylonjs/core/Cameras/deviceOrientationCamera";
import { VRDeviceOrientationFreeCamera as BabylonjsCoreVRDeviceOrientationFreeCamera } from "@babylonjs/core/Cameras/VR/vrDeviceOrientationFreeCamera";
import { VRCameraMetrics as BabylonjsCoreVRCameraMetrics } from "@babylonjs/core/Cameras/VR/vrCameraMetrics";
import { VRDeviceOrientationGamepadCamera as BabylonjsCoreVRDeviceOrientationGamepadCamera } from "@babylonjs/core/Cameras/VR/vrDeviceOrientationGamepadCamera";
import { AnaglyphFreeCamera as BabylonjsCoreAnaglyphFreeCamera } from "@babylonjs/core/Cameras/Stereoscopic/anaglyphFreeCamera";
import { StereoscopicFreeCamera as BabylonjsCoreStereoscopicFreeCamera } from "@babylonjs/core/Cameras/Stereoscopic/stereoscopicFreeCamera";
import { VirtualJoysticksCamera as BabylonjsCoreVirtualJoysticksCamera } from "@babylonjs/core/Cameras/virtualJoysticksCamera";
import { WebVRFreeCamera as BabylonjsCoreWebVRFreeCamera, DevicePose as BabylonjsCoreDevicePose, WebVROptions as BabylonjsCoreWebVROptions } from "@babylonjs/core/Cameras/VR/webVRCamera";
import { WebVRController as BabylonjsCoreWebVRController } from "@babylonjs/core/Gamepads/Controllers/webVRController";
import { WebXRCamera as BabylonjsCoreWebXRCamera } from "@babylonjs/core/XR/webXRCamera";
import { WebXRSessionManager as BabylonjsCoreWebXRSessionManager } from "@babylonjs/core/XR/webXRSessionManager";
import { ArcRotateCamera as BabylonjsCoreArcRotateCamera } from "@babylonjs/core/Cameras/arcRotateCamera";
import { ArcRotateCameraInputsManager as BabylonjsCoreArcRotateCameraInputsManager } from "@babylonjs/core/Cameras/arcRotateCameraInputsManager";
import { AnaglyphArcRotateCamera as BabylonjsCoreAnaglyphArcRotateCamera } from "@babylonjs/core/Cameras/Stereoscopic/anaglyphArcRotateCamera";
import { StereoscopicArcRotateCamera as BabylonjsCoreStereoscopicArcRotateCamera } from "@babylonjs/core/Cameras/Stereoscopic/stereoscopicArcRotateCamera";
import { VRDeviceOrientationArcRotateCamera as BabylonjsCoreVRDeviceOrientationArcRotateCamera } from "@babylonjs/core/Cameras/VR/vrDeviceOrientationArcRotateCamera";
import { FlyCamera as BabylonjsCoreFlyCamera } from "@babylonjs/core/Cameras/flyCamera";
import { FlyCameraInputsManager as BabylonjsCoreFlyCameraInputsManager } from "@babylonjs/core/Cameras/flyCameraInputsManager";
import { FollowCamera as BabylonjsCoreFollowCamera, ArcFollowCamera as BabylonjsCoreArcFollowCamera } from "@babylonjs/core/Cameras/followCamera";
import { FollowCameraInputsManager as BabylonjsCoreFollowCameraInputsManager } from "@babylonjs/core/Cameras/followCameraInputsManager";
import { LinesMesh as BabylonjsCoreLinesMesh } from "@babylonjs/core/Meshes/linesMesh";
import { Plane as BabylonjsCorePlane } from "@babylonjs/core/Maths/math.plane";
import { GroundMesh as BabylonjsCoreGroundMesh } from "@babylonjs/core/Meshes/groundMesh";
import { SmartArray as BabylonjsCoreSmartArray, ISmartArrayLike as BabylonjsCoreISmartArrayLike } from "@babylonjs/core/Misc/smartArray";
import { Effect as BabylonjsCoreEffect } from "@babylonjs/core/Materials/effect";
import { ShaderMaterial as BabylonjsCoreShaderMaterial, IShaderMaterialOptions as BabylonjsCoreIShaderMaterialOptions } from "@babylonjs/core/Materials/shaderMaterial";
import { Texture as BabylonjsCoreTexture } from "@babylonjs/core/Materials/Textures/texture";
import { MultiMaterial as BabylonjsCoreMultiMaterial } from "@babylonjs/core/Materials/multiMaterial";
import { PushMaterial as BabylonjsCorePushMaterial } from "@babylonjs/core/Materials/pushMaterial";
import { StandardMaterial as BabylonjsCoreStandardMaterial, StandardMaterialDefines as BabylonjsCoreStandardMaterialDefines } from "@babylonjs/core/Materials/standardMaterial";
import { ColorCurves as BabylonjsCoreColorCurves } from "@babylonjs/core/Materials/colorCurves";
import { FresnelParameters as BabylonjsCoreFresnelParameters } from "@babylonjs/core/Materials/fresnelParameters";
import { ImageProcessingConfiguration as BabylonjsCoreImageProcessingConfiguration } from "@babylonjs/core/Materials/imageProcessingConfiguration";
import { BackgroundMaterial as BabylonjsCoreBackgroundMaterial } from "@babylonjs/core/Materials/Background/backgroundMaterial";
import { IShadowLight as BabylonjsCoreIShadowLight, ShadowLight as BabylonjsCoreShadowLight } from "@babylonjs/core/Lights/shadowLight";
import { PBRBaseMaterial as BabylonjsCorePBRBaseMaterial, PBRMaterialDefines as BabylonjsCorePBRMaterialDefines } from "@babylonjs/core/Materials/PBR/pbrBaseMaterial";
import { PBRBaseSimpleMaterial as BabylonjsCorePBRBaseSimpleMaterial } from "@babylonjs/core/Materials/PBR/pbrBaseSimpleMaterial";
import { PBRMetallicRoughnessMaterial as BabylonjsCorePBRMetallicRoughnessMaterial } from "@babylonjs/core/Materials/PBR/pbrMetallicRoughnessMaterial";
import { PBRSpecularGlossinessMaterial as BabylonjsCorePBRSpecularGlossinessMaterial } from "@babylonjs/core/Materials/PBR/pbrSpecularGlossinessMaterial";
import { PBRMaterial as BabylonjsCorePBRMaterial } from "@babylonjs/core/Materials/PBR/pbrMaterial";
import { NodeMaterial as BabylonjsCoreNodeMaterial, INodeMaterialOptions as BabylonjsCoreINodeMaterialOptions } from "@babylonjs/core/Materials/Node/nodeMaterial";
import { NodeMaterialBlock as BabylonjsCoreNodeMaterialBlock } from "@babylonjs/core/Materials/Node/nodeMaterialBlock";
import { FluentMaterial as BabylonjsGuiFluentMaterial } from "@babylonjs/gui/3D/materials/fluentMaterial";
import { DirectionalLight as BabylonjsCoreDirectionalLight } from "@babylonjs/core/Lights/directionalLight";
import { PointLight as BabylonjsCorePointLight } from "@babylonjs/core/Lights/pointLight";
import { SpotLight as BabylonjsCoreSpotLight } from "@babylonjs/core/Lights/spotLight";
import { HemisphericLight as BabylonjsCoreHemisphericLight } from "@babylonjs/core/Lights/hemisphericLight";
import { Container as BabylonjsGuiContainer } from "@babylonjs/gui/2D/controls/container";
import { Style as BabylonjsGuiStyle } from "@babylonjs/gui/2D/style";
import { Rectangle as BabylonjsGuiRectangle } from "@babylonjs/gui/2D/controls/rectangle";
import { Button as BabylonjsGuiButton } from "@babylonjs/gui/2D/controls/button";
import { SelectionPanel as BabylonjsGuiSelectionPanel, SelectorGroup as BabylonjsGuiSelectorGroup } from "@babylonjs/gui/2D/controls/selector";
import { ScrollViewer as BabylonjsGuiScrollViewer } from "@babylonjs/gui/2D/controls/scrollViewers/scrollViewer";
import { Image as BabylonjsGuiImage } from "@babylonjs/gui/2D/controls/image";
import { StackPanel as BabylonjsGuiStackPanel } from "@babylonjs/gui/2D/controls/stackPanel";
import { VirtualKeyboard as BabylonjsGuiVirtualKeyboard } from "@babylonjs/gui/2D/controls/virtualKeyboard";
import { Ellipse as BabylonjsGuiEllipse } from "@babylonjs/gui/2D/controls/ellipse";
import { Grid as BabylonjsGuiGrid } from "@babylonjs/gui/2D/controls/grid";
import { _ScrollViewerWindow as BabylonjsGui_ScrollViewerWindow } from "@babylonjs/gui/2D/controls/scrollViewers/scrollViewerWindow";
import { Checkbox as BabylonjsGuiCheckbox } from "@babylonjs/gui/2D/controls/checkbox";
import { ColorPicker as BabylonjsGuiColorPicker } from "@babylonjs/gui/2D/controls/colorpicker";
import { InputText as BabylonjsGuiInputText } from "@babylonjs/gui/2D/controls/inputText";
import { InputPassword as BabylonjsGuiInputPassword } from "@babylonjs/gui/2D/controls/inputPassword";
import { Line as BabylonjsGuiLine } from "@babylonjs/gui/2D/controls/line";
import { MultiLine as BabylonjsGuiMultiLine } from "@babylonjs/gui/2D/controls/multiLine";
import { RadioButton as BabylonjsGuiRadioButton } from "@babylonjs/gui/2D/controls/radioButton";
import { BaseSlider as BabylonjsGuiBaseSlider } from "@babylonjs/gui/2D/controls/sliders/baseSlider";
import { ScrollBar as BabylonjsGuiScrollBar } from "@babylonjs/gui/2D/controls/sliders/scrollBar";
import { ImageScrollBar as BabylonjsGuiImageScrollBar } from "@babylonjs/gui/2D/controls/sliders/imageScrollBar";
import { Slider as BabylonjsGuiSlider } from "@babylonjs/gui/2D/controls/sliders/slider";
import { ImageBasedSlider as BabylonjsGuiImageBasedSlider } from "@babylonjs/gui/2D/controls/sliders/imageBasedSlider";
import { DisplayGrid as BabylonjsGuiDisplayGrid } from "@babylonjs/gui/2D/controls/displayGrid";
import { Container3D as BabylonjsGuiContainer3D } from "@babylonjs/gui/3D/controls/container3D";
import { VolumeBasedPanel as BabylonjsGuiVolumeBasedPanel } from "@babylonjs/gui/3D/controls/volumeBasedPanel";
import { CylinderPanel as BabylonjsGuiCylinderPanel } from "@babylonjs/gui/3D/controls/cylinderPanel";
import { PlanePanel as BabylonjsGuiPlanePanel } from "@babylonjs/gui/3D/controls/planePanel";
import { ScatterPanel as BabylonjsGuiScatterPanel } from "@babylonjs/gui/3D/controls/scatterPanel";
import { SpherePanel as BabylonjsGuiSpherePanel } from "@babylonjs/gui/3D/controls/spherePanel";
import { StackPanel3D as BabylonjsGuiStackPanel3D } from "@babylonjs/gui/3D/controls/stackPanel3D";
import { AbstractButton3D as BabylonjsGuiAbstractButton3D } from "@babylonjs/gui/3D/controls/abstractButton3D";
import { Button3D as BabylonjsGuiButton3D } from "@babylonjs/gui/3D/controls/button3D";
import { HolographicButton as BabylonjsGuiHolographicButton } from "@babylonjs/gui/3D/controls/holographicButton";
import { MeshButton3D as BabylonjsGuiMeshButton3D } from "@babylonjs/gui/3D/controls/meshButton3D";
import { GlowLayer as BabylonjsCoreGlowLayer, IGlowLayerOptions as BabylonjsCoreIGlowLayerOptions } from "@babylonjs/core/Layers/glowLayer";
import { HighlightLayer as BabylonjsCoreHighlightLayer, IHighlightLayerOptions as BabylonjsCoreIHighlightLayerOptions } from "@babylonjs/core/Layers/highlightLayer";
import { CubeTexture as BabylonjsCoreCubeTexture } from "@babylonjs/core/Materials/Textures/cubeTexture";
import { RawCubeTexture as BabylonjsCoreRawCubeTexture } from "@babylonjs/core/Materials/Textures/rawCubeTexture";
import { RawTexture as BabylonjsCoreRawTexture } from "@babylonjs/core/Materials/Textures/rawTexture";
import { ProceduralTexture as BabylonjsCoreProceduralTexture } from "@babylonjs/core/Materials/Textures/Procedurals/proceduralTexture";
import { CustomProceduralTexture as BabylonjsCoreCustomProceduralTexture } from "@babylonjs/core/Materials/Textures/Procedurals/customProceduralTexture";
import { NoiseProceduralTexture as BabylonjsCoreNoiseProceduralTexture } from "@babylonjs/core/Materials/Textures/Procedurals/noiseProceduralTexture";
import { Engine as BabylonjsCoreEngine } from "@babylonjs/core/Engines/engine";
import { PostProcess as BabylonjsCorePostProcess } from "@babylonjs/core/PostProcesses/postProcess";
import { MirrorTexture as BabylonjsCoreMirrorTexture } from "@babylonjs/core/Materials/Textures/mirrorTexture";
import { MultiRenderTarget as BabylonjsCoreMultiRenderTarget, IMultiRenderTargetOptions as BabylonjsCoreIMultiRenderTargetOptions } from "@babylonjs/core/Materials/Textures/multiRenderTarget";
import { RefractionTexture as BabylonjsCoreRefractionTexture } from "@babylonjs/core/Materials/Textures/refractionTexture";
import { MultiviewRenderTarget as BabylonjsCoreMultiviewRenderTarget } from "@babylonjs/core/Materials/Textures/MultiviewRenderTarget";
import { VideoTexture as BabylonjsCoreVideoTexture, VideoTextureSettings as BabylonjsCoreVideoTextureSettings } from "@babylonjs/core/Materials/Textures/videoTexture";
import { DynamicTexture as BabylonjsCoreDynamicTexture } from "@babylonjs/core/Materials/Textures/dynamicTexture";
import { RawTexture3D as BabylonjsCoreRawTexture3D } from "@babylonjs/core/Materials/Textures/rawTexture3D";
import { RawTexture2DArray as BabylonjsCoreRawTexture2DArray } from "@babylonjs/core/Materials/Textures/rawTexture2DArray";
import { ColorGradingTexture as BabylonjsCoreColorGradingTexture } from "@babylonjs/core/Materials/Textures/colorGradingTexture";
import { EquiRectangularCubeTexture as BabylonjsCoreEquiRectangularCubeTexture } from "@babylonjs/core/Materials/Textures/equiRectangularCubeTexture";
import { HDRCubeTexture as BabylonjsCoreHDRCubeTexture } from "@babylonjs/core/Materials/Textures/hdrCubeTexture";
import { HtmlElementTexture as BabylonjsCoreHtmlElementTexture, IHtmlElementTextureOptions as BabylonjsCoreIHtmlElementTextureOptions } from "@babylonjs/core/Materials/Textures/htmlElementTexture";
import { PickingInfo as BabylonjsCorePickingInfo } from "@babylonjs/core/Collisions/pickingInfo";
import { WebXRDefaultExperience as BabylonjsCoreWebXRDefaultExperience } from "@babylonjs/core/XR/webXRDefaultExperience";
import { SolidParticleSystem as BabylonjsCoreSolidParticleSystem } from "@babylonjs/core/Particles/solidParticleSystem";
import { Collider as BabylonjsCoreCollider } from "@babylonjs/core/Collisions/collider";
import { Ray as BabylonjsCoreRay } from "@babylonjs/core/Culling/ray";
import { IOfflineProvider as BabylonjsCoreIOfflineProvider } from "@babylonjs/core/Offline/IOfflineProvider";
import { PointerEventTypes as BabylonjsCorePointerEventTypes } from "@babylonjs/core/Events/pointerEvents";
import { PostProcessManager as BabylonjsCorePostProcessManager } from "@babylonjs/core/PostProcesses/postProcessManager";
export declare type BabylonNode<T> = {
    children?: ReactNode;
    key?: Key;
    onCreated?: (instance: T, scene: BabylonjsCoreScene) => void;
    ref?: Ref<ReactNode>;
};
declare global {
    namespace JSX {
        interface IntrinsicElements {
            node: FiberNodeProps & FiberNodePropsCtor & BabylonNode<BabylonjsCoreNode>;
            transformNode: FiberTransformNodeProps & FiberTransformNodePropsCtor & BabylonNode<BabylonjsCoreTransformNode>;
            abstractMesh: FiberAbstractMeshProps & FiberAbstractMeshPropsCtor & BabylonNode<BabylonjsCoreAbstractMesh>;
            mesh: FiberMeshProps & FiberMeshPropsCtor & BabylonNode<BabylonjsCoreMesh>;
            camera: FiberCameraProps & FiberCameraPropsCtor & BabylonNode<BabylonjsCoreCamera>;
            targetCamera: FiberTargetCameraProps & FiberTargetCameraPropsCtor & BabylonNode<BabylonjsCoreTargetCamera>;
            freeCamera: FiberFreeCameraProps & FiberFreeCameraPropsCtor & BabylonNode<BabylonjsCoreFreeCamera>;
            touchCamera: FiberTouchCameraProps & FiberTouchCameraPropsCtor & BabylonNode<BabylonjsCoreTouchCamera>;
            universalCamera: FiberUniversalCameraProps & FiberUniversalCameraPropsCtor & BabylonNode<BabylonjsCoreUniversalCamera>;
            gamepadCamera: FiberGamepadCameraProps & FiberGamepadCameraPropsCtor & BabylonNode<BabylonjsCoreGamepadCamera>;
            anaglyphGamepadCamera: FiberAnaglyphGamepadCameraProps & FiberAnaglyphGamepadCameraPropsCtor & BabylonNode<BabylonjsCoreAnaglyphGamepadCamera>;
            stereoscopicGamepadCamera: FiberStereoscopicGamepadCameraProps & FiberStereoscopicGamepadCameraPropsCtor & BabylonNode<BabylonjsCoreStereoscopicGamepadCamera>;
            anaglyphUniversalCamera: FiberAnaglyphUniversalCameraProps & FiberAnaglyphUniversalCameraPropsCtor & BabylonNode<BabylonjsCoreAnaglyphUniversalCamera>;
            stereoscopicUniversalCamera: FiberStereoscopicUniversalCameraProps & FiberStereoscopicUniversalCameraPropsCtor & BabylonNode<BabylonjsCoreStereoscopicUniversalCamera>;
            deviceOrientationCamera: FiberDeviceOrientationCameraProps & FiberDeviceOrientationCameraPropsCtor & BabylonNode<BabylonjsCoreDeviceOrientationCamera>;
            vrDeviceOrientationFreeCamera: FiberVRDeviceOrientationFreeCameraProps & FiberVRDeviceOrientationFreeCameraPropsCtor & BabylonNode<BabylonjsCoreVRDeviceOrientationFreeCamera>;
            vrDeviceOrientationGamepadCamera: FiberVRDeviceOrientationGamepadCameraProps & FiberVRDeviceOrientationGamepadCameraPropsCtor & BabylonNode<BabylonjsCoreVRDeviceOrientationGamepadCamera>;
            anaglyphFreeCamera: FiberAnaglyphFreeCameraProps & FiberAnaglyphFreeCameraPropsCtor & BabylonNode<BabylonjsCoreAnaglyphFreeCamera>;
            stereoscopicFreeCamera: FiberStereoscopicFreeCameraProps & FiberStereoscopicFreeCameraPropsCtor & BabylonNode<BabylonjsCoreStereoscopicFreeCamera>;
            virtualJoysticksCamera: FiberVirtualJoysticksCameraProps & FiberVirtualJoysticksCameraPropsCtor & BabylonNode<BabylonjsCoreVirtualJoysticksCamera>;
            webVrFreeCamera: FiberWebVRFreeCameraProps & FiberWebVRFreeCameraPropsCtor & BabylonNode<BabylonjsCoreWebVRFreeCamera>;
            webXrCamera: FiberWebXRCameraProps & FiberWebXRCameraPropsCtor & BabylonNode<BabylonjsCoreWebXRCamera>;
            arcRotateCamera: FiberArcRotateCameraProps & FiberArcRotateCameraPropsCtor & BabylonNode<BabylonjsCoreArcRotateCamera>;
            anaglyphArcRotateCamera: FiberAnaglyphArcRotateCameraProps & FiberAnaglyphArcRotateCameraPropsCtor & BabylonNode<BabylonjsCoreAnaglyphArcRotateCamera>;
            stereoscopicArcRotateCamera: FiberStereoscopicArcRotateCameraProps & FiberStereoscopicArcRotateCameraPropsCtor & BabylonNode<BabylonjsCoreStereoscopicArcRotateCamera>;
            vrDeviceOrientationArcRotateCamera: FiberVRDeviceOrientationArcRotateCameraProps & FiberVRDeviceOrientationArcRotateCameraPropsCtor & BabylonNode<BabylonjsCoreVRDeviceOrientationArcRotateCamera>;
            flyCamera: FiberFlyCameraProps & FiberFlyCameraPropsCtor & BabylonNode<BabylonjsCoreFlyCamera>;
            followCamera: FiberFollowCameraProps & FiberFollowCameraPropsCtor & BabylonNode<BabylonjsCoreFollowCamera>;
            arcFollowCamera: FiberArcFollowCameraProps & FiberArcFollowCameraPropsCtor & BabylonNode<BabylonjsCoreArcFollowCamera>;
            box: FiberMeshProps & FiberBoxPropsCtor & BabylonNode<BabylonjsCoreMesh>;
            tiledBox: FiberMeshProps & FiberTiledBoxPropsCtor & BabylonNode<BabylonjsCoreMesh>;
            sphere: FiberMeshProps & FiberSpherePropsCtor & BabylonNode<BabylonjsCoreMesh>;
            disc: FiberMeshProps & FiberDiscPropsCtor & BabylonNode<BabylonjsCoreMesh>;
            icoSphere: FiberMeshProps & FiberIcoSpherePropsCtor & BabylonNode<BabylonjsCoreMesh>;
            ribbon: FiberMeshProps & FiberRibbonPropsCtor & BabylonNode<BabylonjsCoreMesh>;
            cylinder: FiberMeshProps & FiberCylinderPropsCtor & BabylonNode<BabylonjsCoreMesh>;
            torus: FiberMeshProps & FiberTorusPropsCtor & BabylonNode<BabylonjsCoreMesh>;
            torusKnot: FiberMeshProps & FiberTorusKnotPropsCtor & BabylonNode<BabylonjsCoreMesh>;
            lineSystem: FiberMeshProps & FiberLineSystemPropsCtor & BabylonNode<BabylonjsCoreMesh>;
            lines: FiberMeshProps & FiberLinesPropsCtor & BabylonNode<BabylonjsCoreMesh>;
            dashedLines: FiberMeshProps & FiberDashedLinesPropsCtor & BabylonNode<BabylonjsCoreMesh>;
            extrudeShape: FiberMeshProps & FiberExtrudeShapePropsCtor & BabylonNode<BabylonjsCoreMesh>;
            extrudeShapeCustom: FiberMeshProps & FiberExtrudeShapeCustomPropsCtor & BabylonNode<BabylonjsCoreMesh>;
            lathe: FiberMeshProps & FiberLathePropsCtor & BabylonNode<BabylonjsCoreMesh>;
            tiledPlane: FiberMeshProps & FiberTiledPlanePropsCtor & BabylonNode<BabylonjsCoreMesh>;
            plane: FiberMeshProps & FiberPlanePropsCtor & BabylonNode<BabylonjsCoreMesh>;
            ground: FiberMeshProps & FiberGroundPropsCtor & BabylonNode<BabylonjsCoreMesh>;
            tiledGround: FiberMeshProps & FiberTiledGroundPropsCtor & BabylonNode<BabylonjsCoreMesh>;
            groundFromHeightMap: FiberMeshProps & FiberGroundFromHeightMapPropsCtor & BabylonNode<BabylonjsCoreMesh>;
            'babylon-polygon': FiberMeshProps & FiberPolygonPropsCtor & BabylonNode<BabylonjsCoreMesh>;
            extrudePolygon: FiberMeshProps & FiberExtrudePolygonPropsCtor & BabylonNode<BabylonjsCoreMesh>;
            tube: FiberMeshProps & FiberTubePropsCtor & BabylonNode<BabylonjsCoreMesh>;
            polyhedron: FiberMeshProps & FiberPolyhedronPropsCtor & BabylonNode<BabylonjsCoreMesh>;
            decal: FiberMeshProps & FiberDecalPropsCtor & BabylonNode<BabylonjsCoreMesh>;
            material: FiberMaterialProps & FiberMaterialPropsCtor & BabylonNode<BabylonjsCoreMaterial>;
            shaderMaterial: FiberShaderMaterialProps & FiberShaderMaterialPropsCtor & BabylonNode<BabylonjsCoreShaderMaterial>;
            multiMaterial: FiberMultiMaterialProps & FiberMultiMaterialPropsCtor & BabylonNode<BabylonjsCoreMultiMaterial>;
            pushMaterial: FiberPushMaterialProps & FiberPushMaterialPropsCtor & BabylonNode<BabylonjsCorePushMaterial>;
            standardMaterial: FiberStandardMaterialProps & FiberStandardMaterialPropsCtor & BabylonNode<BabylonjsCoreStandardMaterial>;
            backgroundMaterial: FiberBackgroundMaterialProps & FiberBackgroundMaterialPropsCtor & BabylonNode<BabylonjsCoreBackgroundMaterial>;
            pbrBaseMaterial: FiberPBRBaseMaterialProps & FiberPBRBaseMaterialPropsCtor & BabylonNode<BabylonjsCorePBRBaseMaterial>;
            pbrBaseSimpleMaterial: FiberPBRBaseSimpleMaterialProps & FiberPBRBaseSimpleMaterialPropsCtor & BabylonNode<BabylonjsCorePBRBaseSimpleMaterial>;
            pbrMetallicRoughnessMaterial: FiberPBRMetallicRoughnessMaterialProps & FiberPBRMetallicRoughnessMaterialPropsCtor & BabylonNode<BabylonjsCorePBRMetallicRoughnessMaterial>;
            pbrSpecularGlossinessMaterial: FiberPBRSpecularGlossinessMaterialProps & FiberPBRSpecularGlossinessMaterialPropsCtor & BabylonNode<BabylonjsCorePBRSpecularGlossinessMaterial>;
            pbrMaterial: FiberPBRMaterialProps & FiberPBRMaterialPropsCtor & BabylonNode<BabylonjsCorePBRMaterial>;
            nodeMaterial: FiberNodeMaterialProps & FiberNodeMaterialPropsCtor & BabylonNode<BabylonjsCoreNodeMaterial>;
            fluentMaterial: FiberFluentMaterialProps & FiberFluentMaterialPropsCtor & BabylonNode<BabylonjsGuiFluentMaterial>;
            light: FiberLightProps & FiberLightPropsCtor & BabylonNode<BabylonjsCoreLight>;
            shadowLight: FiberShadowLightProps & FiberShadowLightPropsCtor & BabylonNode<BabylonjsCoreShadowLight>;
            directionalLight: FiberDirectionalLightProps & FiberDirectionalLightPropsCtor & BabylonNode<BabylonjsCoreDirectionalLight>;
            pointLight: FiberPointLightProps & FiberPointLightPropsCtor & BabylonNode<BabylonjsCorePointLight>;
            spotLight: FiberSpotLightProps & FiberSpotLightPropsCtor & BabylonNode<BabylonjsCoreSpotLight>;
            hemisphericLight: FiberHemisphericLightProps & FiberHemisphericLightPropsCtor & BabylonNode<BabylonjsCoreHemisphericLight>;
            control: FiberControlProps & FiberControlPropsCtor & BabylonNode<BabylonjsGuiControl>;
            container: FiberContainerProps & FiberContainerPropsCtor & BabylonNode<BabylonjsGuiContainer>;
            rectangle: FiberRectangleProps & FiberRectanglePropsCtor & BabylonNode<BabylonjsGuiRectangle>;
            'babylon-button': FiberButtonProps & FiberButtonPropsCtor & BabylonNode<BabylonjsGuiButton>;
            selectionPanel: FiberSelectionPanelProps & FiberSelectionPanelPropsCtor & BabylonNode<BabylonjsGuiSelectionPanel>;
            scrollViewer: FiberScrollViewerProps & FiberScrollViewerPropsCtor & BabylonNode<BabylonjsGuiScrollViewer>;
            stackPanel: FiberStackPanelProps & FiberStackPanelPropsCtor & BabylonNode<BabylonjsGuiStackPanel>;
            virtualKeyboard: FiberVirtualKeyboardProps & FiberVirtualKeyboardPropsCtor & BabylonNode<BabylonjsGuiVirtualKeyboard>;
            'babylon-ellipse': FiberEllipseProps & FiberEllipsePropsCtor & BabylonNode<BabylonjsGuiEllipse>;
            grid: FiberGridProps & FiberGridPropsCtor & BabylonNode<BabylonjsGuiGrid>;
            scrollViewerWindow: Fiber_ScrollViewerWindowProps & Fiber_ScrollViewerWindowPropsCtor & BabylonNode<BabylonjsGui_ScrollViewerWindow>;
            textBlock: FiberTextBlockProps & FiberTextBlockPropsCtor & BabylonNode<BabylonjsGuiTextBlock>;
            'babylon-image': FiberImageProps & FiberImagePropsCtor & BabylonNode<BabylonjsGuiImage>;
            checkbox: FiberCheckboxProps & FiberCheckboxPropsCtor & BabylonNode<BabylonjsGuiCheckbox>;
            colorPicker: FiberColorPickerProps & FiberColorPickerPropsCtor & BabylonNode<BabylonjsGuiColorPicker>;
            inputText: FiberInputTextProps & FiberInputTextPropsCtor & BabylonNode<BabylonjsGuiInputText>;
            inputPassword: FiberInputPasswordProps & FiberInputPasswordPropsCtor & BabylonNode<BabylonjsGuiInputPassword>;
            'babylon-line': FiberLineProps & FiberLinePropsCtor & BabylonNode<BabylonjsGuiLine>;
            multiLine: FiberMultiLineProps & FiberMultiLinePropsCtor & BabylonNode<BabylonjsGuiMultiLine>;
            radioButton: FiberRadioButtonProps & FiberRadioButtonPropsCtor & BabylonNode<BabylonjsGuiRadioButton>;
            baseSlider: FiberBaseSliderProps & FiberBaseSliderPropsCtor & BabylonNode<BabylonjsGuiBaseSlider>;
            scrollBar: FiberScrollBarProps & FiberScrollBarPropsCtor & BabylonNode<BabylonjsGuiScrollBar>;
            imageScrollBar: FiberImageScrollBarProps & FiberImageScrollBarPropsCtor & BabylonNode<BabylonjsGuiImageScrollBar>;
            slider: FiberSliderProps & FiberSliderPropsCtor & BabylonNode<BabylonjsGuiSlider>;
            imageBasedSlider: FiberImageBasedSliderProps & FiberImageBasedSliderPropsCtor & BabylonNode<BabylonjsGuiImageBasedSlider>;
            displayGrid: FiberDisplayGridProps & FiberDisplayGridPropsCtor & BabylonNode<BabylonjsGuiDisplayGrid>;
            control3D: FiberControl3DProps & FiberControl3DPropsCtor & BabylonNode<BabylonjsGuiControl3D>;
            container3D: FiberContainer3DProps & FiberContainer3DPropsCtor & BabylonNode<BabylonjsGuiContainer3D>;
            volumeBasedPanel: FiberVolumeBasedPanelProps & FiberVolumeBasedPanelPropsCtor & BabylonNode<BabylonjsGuiVolumeBasedPanel>;
            cylinderPanel: FiberCylinderPanelProps & FiberCylinderPanelPropsCtor & BabylonNode<BabylonjsGuiCylinderPanel>;
            planePanel: FiberPlanePanelProps & FiberPlanePanelPropsCtor & BabylonNode<BabylonjsGuiPlanePanel>;
            scatterPanel: FiberScatterPanelProps & FiberScatterPanelPropsCtor & BabylonNode<BabylonjsGuiScatterPanel>;
            spherePanel: FiberSpherePanelProps & FiberSpherePanelPropsCtor & BabylonNode<BabylonjsGuiSpherePanel>;
            stackPanel3D: FiberStackPanel3DProps & FiberStackPanel3DPropsCtor & BabylonNode<BabylonjsGuiStackPanel3D>;
            abstractButton3D: FiberAbstractButton3DProps & FiberAbstractButton3DPropsCtor & BabylonNode<BabylonjsGuiAbstractButton3D>;
            button3D: FiberButton3DProps & FiberButton3DPropsCtor & BabylonNode<BabylonjsGuiButton3D>;
            holographicButton: FiberHolographicButtonProps & FiberHolographicButtonPropsCtor & BabylonNode<BabylonjsGuiHolographicButton>;
            meshButton3D: FiberMeshButton3DProps & FiberMeshButton3DPropsCtor & BabylonNode<BabylonjsGuiMeshButton3D>;
            effectLayer: FiberEffectLayerProps & FiberEffectLayerPropsCtor & BabylonNode<BabylonjsCoreEffectLayer>;
            glowLayer: FiberGlowLayerProps & FiberGlowLayerPropsCtor & BabylonNode<BabylonjsCoreGlowLayer>;
            highlightLayer: FiberHighlightLayerProps & FiberHighlightLayerPropsCtor & BabylonNode<BabylonjsCoreHighlightLayer>;
            baseTexture: FiberBaseTextureProps & FiberBaseTexturePropsCtor & BabylonNode<BabylonjsCoreBaseTexture>;
            cubeTexture: FiberCubeTextureProps & FiberCubeTexturePropsCtor & BabylonNode<BabylonjsCoreCubeTexture>;
            rawCubeTexture: FiberRawCubeTextureProps & FiberRawCubeTexturePropsCtor & BabylonNode<BabylonjsCoreRawCubeTexture>;
            texture: FiberTextureProps & FiberTexturePropsCtor & BabylonNode<BabylonjsCoreTexture>;
            rawTexture: FiberRawTextureProps & FiberRawTexturePropsCtor & BabylonNode<BabylonjsCoreRawTexture>;
            proceduralTexture: FiberProceduralTextureProps & FiberProceduralTexturePropsCtor & BabylonNode<BabylonjsCoreProceduralTexture>;
            customProceduralTexture: FiberCustomProceduralTextureProps & FiberCustomProceduralTexturePropsCtor & BabylonNode<BabylonjsCoreCustomProceduralTexture>;
            noiseProceduralTexture: FiberNoiseProceduralTextureProps & FiberNoiseProceduralTexturePropsCtor & BabylonNode<BabylonjsCoreNoiseProceduralTexture>;
            renderTargetTexture: FiberRenderTargetTextureProps & FiberRenderTargetTexturePropsCtor & BabylonNode<BabylonjsCoreRenderTargetTexture>;
            mirrorTexture: FiberMirrorTextureProps & FiberMirrorTexturePropsCtor & BabylonNode<BabylonjsCoreMirrorTexture>;
            multiRenderTarget: FiberMultiRenderTargetProps & FiberMultiRenderTargetPropsCtor & BabylonNode<BabylonjsCoreMultiRenderTarget>;
            refractionTexture: FiberRefractionTextureProps & FiberRefractionTexturePropsCtor & BabylonNode<BabylonjsCoreRefractionTexture>;
            multiviewRenderTarget: FiberMultiviewRenderTargetProps & FiberMultiviewRenderTargetPropsCtor & BabylonNode<BabylonjsCoreMultiviewRenderTarget>;
            videoTexture: FiberVideoTextureProps & FiberVideoTexturePropsCtor & BabylonNode<BabylonjsCoreVideoTexture>;
            dynamicTexture: FiberDynamicTextureProps & FiberDynamicTexturePropsCtor & BabylonNode<BabylonjsCoreDynamicTexture>;
            advancedDynamicTexture: FiberAdvancedDynamicTextureProps & FiberAdvancedDynamicTexturePropsCtor & BabylonNode<BabylonjsGuiAdvancedDynamicTexture>;
            adtForMesh: FiberAdvancedDynamicTextureProps & FiberADTForMeshPropsCtor & BabylonNode<BabylonjsGuiAdvancedDynamicTexture>;
            adtFullscreenUi: FiberAdvancedDynamicTextureProps & FiberADTFullscreenUIPropsCtor & BabylonNode<BabylonjsGuiAdvancedDynamicTexture>;
            rawTexture3D: FiberRawTexture3DProps & FiberRawTexture3DPropsCtor & BabylonNode<BabylonjsCoreRawTexture3D>;
            rawTexture2DArray: FiberRawTexture2DArrayProps & FiberRawTexture2DArrayPropsCtor & BabylonNode<BabylonjsCoreRawTexture2DArray>;
            colorGradingTexture: FiberColorGradingTextureProps & FiberColorGradingTexturePropsCtor & BabylonNode<BabylonjsCoreColorGradingTexture>;
            equiRectangularCubeTexture: FiberEquiRectangularCubeTextureProps & FiberEquiRectangularCubeTexturePropsCtor & BabylonNode<BabylonjsCoreEquiRectangularCubeTexture>;
            hdrCubeTexture: FiberHDRCubeTextureProps & FiberHDRCubeTexturePropsCtor & BabylonNode<BabylonjsCoreHDRCubeTexture>;
            htmlElementTexture: FiberHtmlElementTextureProps & FiberHtmlElementTexturePropsCtor & BabylonNode<BabylonjsCoreHtmlElementTexture>;
            gui3DManager: FiberGUI3DManagerProps & FiberGUI3DManagerPropsCtor & BabylonNode<BabylonjsGuiGUI3DManager>;
            shadowGenerator: FiberShadowGeneratorProps & FiberShadowGeneratorPropsCtor & BabylonNode<BabylonjsCoreShadowGenerator>;
            environmentHelper: FiberEnvironmentHelperProps & FiberEnvironmentHelperPropsCtor & BabylonNode<BabylonjsCoreEnvironmentHelper>;
            physicsImpostor: FiberPhysicsImpostorProps & FiberPhysicsImpostorPropsCtor & BabylonNode<BabylonjsCorePhysicsImpostor>;
            vrExperienceHelper: FiberVRExperienceHelperProps & FiberVRExperienceHelperPropsCtor & BabylonNode<BabylonjsCoreVRExperienceHelper>;
            dynamicTerrain: FiberDynamicTerrainProps & FiberDynamicTerrainPropsCtor & BabylonNode<ExtensionsDynamicTerrain>;
            autoRotationBehavior: FiberAutoRotationBehaviorProps & FiberAutoRotationBehaviorPropsCtor & BabylonNode<BabylonjsCoreAutoRotationBehavior>;
            bouncingBehavior: FiberBouncingBehaviorProps & FiberBouncingBehaviorPropsCtor & BabylonNode<BabylonjsCoreBouncingBehavior>;
            framingBehavior: FiberFramingBehaviorProps & FiberFramingBehaviorPropsCtor & BabylonNode<BabylonjsCoreFramingBehavior>;
            attachToBoxBehavior: FiberAttachToBoxBehaviorProps & FiberAttachToBoxBehaviorPropsCtor & BabylonNode<BabylonjsCoreAttachToBoxBehavior>;
            fadeInOutBehavior: FiberFadeInOutBehaviorProps & FiberFadeInOutBehaviorPropsCtor & BabylonNode<BabylonjsCoreFadeInOutBehavior>;
            multiPointerScaleBehavior: FiberMultiPointerScaleBehaviorProps & FiberMultiPointerScaleBehaviorPropsCtor & BabylonNode<BabylonjsCoreMultiPointerScaleBehavior>;
            pointerDragBehavior: FiberPointerDragBehaviorProps & FiberPointerDragBehaviorPropsCtor & BabylonNode<BabylonjsCorePointerDragBehavior>;
            sixDofDragBehavior: FiberSixDofDragBehaviorProps & FiberSixDofDragBehaviorPropsCtor & BabylonNode<BabylonjsCoreSixDofDragBehavior>;
            model: ModelProps & BabylonNode<BabylonjsCoreAbstractMesh>;
        }
    }
}
export declare type FiberNodeProps = {
    addBehavior?: any;
    animationPropertiesOverride?: BabylonjsCoreAnimationPropertiesOverride;
    animations?: BabylonjsCoreAnimation[];
    doNotSerialize?: boolean;
    id?: string;
    inspectableCustomProperties?: BabylonjsCoreIInspectable[];
    metadata?: any;
    name?: string;
    onDispose?: () => void;
    onDisposeObservable?: any;
    onReady?: (node: BabylonjsCoreNode) => void;
    parent?: BabylonjsCoreNode;
    reservedDataStore?: any;
    setEnabled?: any;
    state?: string;
    uniqueId?: number;
} & CustomProps;
export declare type FiberNodePropsCtor = {
    name: string;
};
export declare type FiberTransformNodeProps = {
    addRotation?: any;
    billboardMode?: number;
    ignoreNonUniformScaling?: boolean;
    infiniteDistance?: boolean;
    onAfterWorldMatrixUpdateObservable?: any;
    position?: BabylonjsCoreVector3;
    preserveParentRotationForBillboard?: boolean;
    reIntegrateRotationIntoRotationQuaternion?: boolean;
    rotation?: BabylonjsCoreVector3;
    rotationQuaternion?: BabylonjsCoreQuaternion;
    scaling?: BabylonjsCoreVector3;
    scalingDeterminant?: number;
    setAbsolutePosition?: any;
    setDirection?: any;
    setParent?: any;
    setPivotMatrix?: any;
    setPivotPoint?: any;
    setPositionWithLocalVector?: any;
    setPreTransformMatrix?: any;
    translate?: any;
} & FiberNodeProps;
export declare type FiberTransformNodePropsCtor = {
    name: string;
    isPure?: boolean;
};
export declare type FiberAbstractMeshProps = {
    actionManager?: BabylonjsCoreAbstractActionManager;
    addChild?: any;
    alphaIndex?: number;
    alwaysSelectAsActiveMesh?: boolean;
    applyFog?: boolean;
    checkCollisions?: boolean;
    collisionGroup?: number;
    collisionMask?: number;
    computeBonesUsingShaders?: boolean;
    cullingStrategy?: number;
    definedFacingForward?: boolean;
    doNotSyncBoundingInfo?: boolean;
    edgesColor?: BabylonjsCoreColor4;
    edgesWidth?: number;
    ellipsoid?: BabylonjsCoreVector3;
    ellipsoidOffset?: BabylonjsCoreVector3;
    enablePointerMoveEvents?: boolean;
    facetDepthSortFrom?: BabylonjsCoreVector3;
    hasVertexAlpha?: boolean;
    isBlocker?: boolean;
    isPickable?: boolean;
    isVisible?: boolean;
    layerMask?: number;
    material?: BabylonjsCoreMaterial;
    mustDepthSortFacets?: boolean;
    numBoneInfluencers?: number;
    onCollide?: () => void;
    onCollideObservable?: any;
    onCollisionPositionChange?: () => void;
    onCollisionPositionChangeObservable?: any;
    onMaterialChangedObservable?: any;
    onRebuildObservable?: any;
    outlineColor?: BabylonjsCoreColor3;
    outlineWidth?: number;
    overlayAlpha?: number;
    overlayColor?: BabylonjsCoreColor3;
    partitioningBBoxRatio?: number;
    partitioningSubdivisions?: number;
    receiveShadows?: boolean;
    renderingGroupId?: number;
    scaling?: BabylonjsCoreVector3;
    setBoundingInfo?: any;
    setIndices?: any;
    setVerticesData?: any;
    showSubMeshesBoundingBox?: boolean;
    skeleton?: BabylonjsCoreSkeleton;
    subMeshes?: BabylonjsCoreSubMesh[];
    useOctreeForCollisions?: boolean;
    useOctreeForPicking?: boolean;
    useOctreeForRenderingSelection?: boolean;
    useVertexColors?: boolean;
    visibility?: number;
} & FiberTransformNodeProps;
export declare type FiberAbstractMeshPropsCtor = {
    name: string;
};
export declare type FiberMeshProps = {
    addInstance?: any;
    addLODLevel?: any;
    delayLoadingFile?: string;
    delayLoadState?: number;
    instances?: BabylonjsCoreInstancedMesh[];
    isUnIndexed?: boolean;
    manualUpdateOfWorldMatrixInstancedBuffer?: boolean;
    morphTargetManager?: BabylonjsCoreMorphTargetManager;
    normalizeSkinFourWeights?: any;
    normalizeSkinWeightsAndExtra?: any;
    onBeforeDraw?: () => void;
    onLODLevelSelection?: (distance: number, mesh: BabylonjsCoreMesh, selectedLevel: BabylonjsCoreMesh) => void;
    overrideMaterialSideOrientation?: number;
    overridenInstanceCount?: number;
    setIndices?: any;
    setMaterialByID?: any;
    setVerticesBuffer?: any;
    setVerticesData?: any;
} & FiberAbstractMeshProps;
export declare type FiberMeshPropsCtor = {
    name: string;
    parent?: BabylonjsCoreNode;
    source?: BabylonjsCoreMesh;
    doNotCloneChildren?: boolean;
    clonePhysicsImpostor?: boolean;
};
export declare type FiberCameraProps = {
    cameraRigMode?: number;
    customRenderTargets?: BabylonjsCoreRenderTargetTexture[];
    fov?: number;
    fovMode?: number;
    inertia?: number;
    inputs?: BabylonjsCoreCameraInputsManager<BabylonjsCoreCamera>;
    interaxialDistance?: number;
    isIntermediate?: boolean;
    isRigCamera?: boolean;
    isStereoscopicSideBySide?: boolean;
    layerMask?: number;
    maxZ?: number;
    minZ?: number;
    mode?: number;
    onAfterCheckInputsObservable?: any;
    onProjectionMatrixChangedObservable?: any;
    onRestoreStateObservable?: any;
    onViewMatrixChangedObservable?: any;
    orthoBottom?: number;
    orthoLeft?: number;
    orthoRight?: number;
    orthoTop?: number;
    outputRenderTarget?: BabylonjsCoreRenderTargetTexture;
    position?: BabylonjsCoreVector3;
    rigParent?: BabylonjsCoreCamera;
    setCameraRigMode?: any;
    setCameraRigParameter?: any;
    upVector?: BabylonjsCoreVector3;
    viewport?: BabylonjsCoreViewport;
} & FiberNodeProps;
export declare type FiberCameraPropsCtor = {
    name: string;
    position: BabylonjsCoreVector3;
    setActiveOnSceneIfNoneActive?: boolean;
};
export declare type FiberTargetCameraProps = {
    cameraDirection?: BabylonjsCoreVector3;
    cameraRotation?: BabylonjsCoreVector2;
    lockedTarget?: any;
    noRotationConstraint?: boolean;
    rotation?: BabylonjsCoreVector3;
    rotationQuaternion?: BabylonjsCoreQuaternion;
    setTarget?: any;
    speed?: number;
    updateUpVectorFromRotation?: boolean;
} & FiberCameraProps;
export declare type FiberTargetCameraPropsCtor = {
    name: string;
    position: BabylonjsCoreVector3;
    setActiveOnSceneIfNoneActive?: boolean;
};
export declare type FiberFreeCameraProps = {
    angularSensibility?: number;
    applyGravity?: boolean;
    checkCollisions?: boolean;
    collisionMask?: number;
    ellipsoid?: BabylonjsCoreVector3;
    ellipsoidOffset?: BabylonjsCoreVector3;
    inputs?: BabylonjsCoreFreeCameraInputsManager;
    keysDown?: number[];
    keysLeft?: number[];
    keysRight?: number[];
    keysUp?: number[];
    onCollide?: (collidedMesh: BabylonjsCoreAbstractMesh) => void;
} & FiberTargetCameraProps;
export declare type FiberFreeCameraPropsCtor = {
    name: string;
    position: BabylonjsCoreVector3;
    setActiveOnSceneIfNoneActive?: boolean;
};
export declare type FiberTouchCameraProps = {
    touchAngularSensibility?: number;
    touchMoveSensibility?: number;
} & FiberFreeCameraProps;
export declare type FiberTouchCameraPropsCtor = {
    name: string;
    position: BabylonjsCoreVector3;
};
export declare type FiberUniversalCameraProps = {
    gamepadAngularSensibility?: number;
    gamepadMoveSensibility?: number;
} & FiberTouchCameraProps;
export declare type FiberUniversalCameraPropsCtor = {
    name: string;
    position: BabylonjsCoreVector3;
};
export declare type FiberGamepadCameraProps = {} & FiberUniversalCameraProps;
export declare type FiberGamepadCameraPropsCtor = {
    name: string;
    position: BabylonjsCoreVector3;
};
export declare type FiberAnaglyphGamepadCameraProps = {} & FiberGamepadCameraProps;
export declare type FiberAnaglyphGamepadCameraPropsCtor = {
    name: string;
    position: BabylonjsCoreVector3;
    interaxialDistance: number;
};
export declare type FiberStereoscopicGamepadCameraProps = {} & FiberGamepadCameraProps;
export declare type FiberStereoscopicGamepadCameraPropsCtor = {
    name: string;
    position: BabylonjsCoreVector3;
    interaxialDistance: number;
    isStereoscopicSideBySide: boolean;
};
export declare type FiberAnaglyphUniversalCameraProps = {} & FiberUniversalCameraProps;
export declare type FiberAnaglyphUniversalCameraPropsCtor = {
    name: string;
    position: BabylonjsCoreVector3;
    interaxialDistance: number;
};
export declare type FiberStereoscopicUniversalCameraProps = {} & FiberUniversalCameraProps;
export declare type FiberStereoscopicUniversalCameraPropsCtor = {
    name: string;
    position: BabylonjsCoreVector3;
    interaxialDistance: number;
    isStereoscopicSideBySide: boolean;
};
export declare type FiberDeviceOrientationCameraProps = {
    disablePointerInputWhenUsingDeviceOrientation?: boolean;
} & FiberFreeCameraProps;
export declare type FiberDeviceOrientationCameraPropsCtor = {
    name: string;
    position: BabylonjsCoreVector3;
};
export declare type FiberVRDeviceOrientationFreeCameraProps = {} & FiberDeviceOrientationCameraProps;
export declare type FiberVRDeviceOrientationFreeCameraPropsCtor = {
    name: string;
    position: BabylonjsCoreVector3;
    compensateDistortion?: boolean;
    vrCameraMetrics?: BabylonjsCoreVRCameraMetrics;
};
export declare type FiberVRDeviceOrientationGamepadCameraProps = {} & FiberVRDeviceOrientationFreeCameraProps;
export declare type FiberVRDeviceOrientationGamepadCameraPropsCtor = {
    name: string;
    position: BabylonjsCoreVector3;
    compensateDistortion?: boolean;
    vrCameraMetrics?: BabylonjsCoreVRCameraMetrics;
};
export declare type FiberAnaglyphFreeCameraProps = {} & FiberFreeCameraProps;
export declare type FiberAnaglyphFreeCameraPropsCtor = {
    name: string;
    position: BabylonjsCoreVector3;
    interaxialDistance: number;
};
export declare type FiberStereoscopicFreeCameraProps = {} & FiberFreeCameraProps;
export declare type FiberStereoscopicFreeCameraPropsCtor = {
    name: string;
    position: BabylonjsCoreVector3;
    interaxialDistance: number;
    isStereoscopicSideBySide: boolean;
};
export declare type FiberVirtualJoysticksCameraProps = {} & FiberFreeCameraProps;
export declare type FiberVirtualJoysticksCameraPropsCtor = {
    name: string;
    position: BabylonjsCoreVector3;
};
export declare type FiberWebVRFreeCameraProps = {
    controllers?: BabylonjsCoreWebVRController[];
    devicePosition?: BabylonjsCoreVector3;
    deviceRotationQuaternion?: BabylonjsCoreQuaternion;
    deviceScaleFactor?: number;
    onControllerMeshLoadedObservable?: any;
    onControllersAttachedObservable?: any;
    onPoseUpdatedFromDeviceObservable?: any;
    rawPose?: BabylonjsCoreDevicePose;
    rigParenting?: boolean;
    updateCacheCalled?: any;
    webVROptions?: any;
} & FiberFreeCameraProps;
export declare type FiberWebVRFreeCameraPropsCtor = {
    name: string;
    position: BabylonjsCoreVector3;
    webVROptions?: BabylonjsCoreWebVROptions;
};
export declare type FiberWebXRCameraProps = {
    compensateOnFirstFrame?: boolean;
    setTransformationFromNonVRCamera?: any;
} & FiberFreeCameraProps;
export declare type FiberWebXRCameraPropsCtor = {
    name: string;
    _xrSessionManager: BabylonjsCoreWebXRSessionManager;
};
export declare type FiberArcRotateCameraProps = {
    allowUpsideDown?: boolean;
    alpha?: number;
    angularSensibilityX?: number;
    angularSensibilityY?: number;
    beta?: number;
    checkCollisions?: boolean;
    collisionRadius?: BabylonjsCoreVector3;
    inertialAlphaOffset?: number;
    inertialBetaOffset?: number;
    inertialPanningX?: number;
    inertialPanningY?: number;
    inertialRadiusOffset?: number;
    inputs?: BabylonjsCoreArcRotateCameraInputsManager;
    keysDown?: number[];
    keysLeft?: number[];
    keysRight?: number[];
    keysUp?: number[];
    lowerAlphaLimit?: number;
    lowerBetaLimit?: number;
    lowerRadiusLimit?: number;
    onCollide?: (collidedMesh: BabylonjsCoreAbstractMesh) => void;
    onMeshTargetChangedObservable?: any;
    panningAxis?: BabylonjsCoreVector3;
    panningDistanceLimit?: number;
    panningInertia?: number;
    panningOriginTarget?: BabylonjsCoreVector3;
    panningSensibility?: number;
    pinchDeltaPercentage?: number;
    pinchPrecision?: number;
    pinchToPanMaxDistance?: number;
    position?: BabylonjsCoreVector3;
    radius?: number;
    setPosition?: any;
    setTarget?: any;
    target?: BabylonjsCoreVector3;
    targetScreenOffset?: BabylonjsCoreVector2;
    upperAlphaLimit?: number;
    upperBetaLimit?: number;
    upperRadiusLimit?: number;
    upVector?: BabylonjsCoreVector3;
    useAutoRotationBehavior?: boolean;
    useBouncingBehavior?: boolean;
    useFramingBehavior?: boolean;
    useInputToRestoreState?: boolean;
    useNaturalPinchZoom?: boolean;
    wheelDeltaPercentage?: number;
    wheelPrecision?: number;
    zoomOnFactor?: number;
} & FiberTargetCameraProps;
export declare type FiberArcRotateCameraPropsCtor = {
    name: string;
    alpha: number;
    beta: number;
    radius: number;
    target: BabylonjsCoreVector3;
    setActiveOnSceneIfNoneActive?: boolean;
};
export declare type FiberAnaglyphArcRotateCameraProps = {} & FiberArcRotateCameraProps;
export declare type FiberAnaglyphArcRotateCameraPropsCtor = {
    name: string;
    alpha: number;
    beta: number;
    radius: number;
    target: BabylonjsCoreVector3;
    interaxialDistance: number;
};
export declare type FiberStereoscopicArcRotateCameraProps = {} & FiberArcRotateCameraProps;
export declare type FiberStereoscopicArcRotateCameraPropsCtor = {
    name: string;
    alpha: number;
    beta: number;
    radius: number;
    target: BabylonjsCoreVector3;
    interaxialDistance: number;
    isStereoscopicSideBySide: boolean;
};
export declare type FiberVRDeviceOrientationArcRotateCameraProps = {} & FiberArcRotateCameraProps;
export declare type FiberVRDeviceOrientationArcRotateCameraPropsCtor = {
    name: string;
    alpha: number;
    beta: number;
    radius: number;
    target: BabylonjsCoreVector3;
    compensateDistortion?: boolean;
    vrCameraMetrics?: BabylonjsCoreVRCameraMetrics;
};
export declare type FiberFlyCameraProps = {
    angularSensibility?: number;
    applyGravity?: boolean;
    bankedTurn?: boolean;
    bankedTurnLimit?: number;
    bankedTurnMultiplier?: number;
    cameraDirection?: BabylonjsCoreVector3;
    checkCollisions?: boolean;
    collisionMask?: number;
    ellipsoid?: BabylonjsCoreVector3;
    ellipsoidOffset?: BabylonjsCoreVector3;
    inputs?: BabylonjsCoreFlyCameraInputsManager;
    keysBackward?: number[];
    keysDown?: number[];
    keysForward?: number[];
    keysLeft?: number[];
    keysRight?: number[];
    keysUp?: number[];
    onCollide?: (collidedMesh: BabylonjsCoreAbstractMesh) => void;
    rollCorrect?: number;
    rotationQuaternion?: BabylonjsCoreQuaternion;
} & FiberTargetCameraProps;
export declare type FiberFlyCameraPropsCtor = {
    name: string;
    position: BabylonjsCoreVector3;
    setActiveOnSceneIfNoneActive?: boolean;
};
export declare type FiberFollowCameraProps = {
    cameraAcceleration?: number;
    heightOffset?: number;
    inputs?: BabylonjsCoreFollowCameraInputsManager;
    lockedTarget?: BabylonjsCoreAbstractMesh;
    lowerHeightOffsetLimit?: number;
    lowerRadiusLimit?: number;
    lowerRotationOffsetLimit?: number;
    maxCameraSpeed?: number;
    radius?: number;
    rotationOffset?: number;
    upperHeightOffsetLimit?: number;
    upperRadiusLimit?: number;
    upperRotationOffsetLimit?: number;
} & FiberTargetCameraProps;
export declare type FiberFollowCameraPropsCtor = {
    name: string;
    position: BabylonjsCoreVector3;
    lockedTarget?: BabylonjsCoreAbstractMesh;
};
export declare type FiberArcFollowCameraProps = {
    alpha?: number;
    beta?: number;
    radius?: number;
    target?: BabylonjsCoreAbstractMesh;
} & FiberTargetCameraProps;
export declare type FiberArcFollowCameraPropsCtor = {
    name: string;
    alpha: number;
    beta: number;
    radius: number;
    target: BabylonjsCoreAbstractMesh;
};
export declare type FiberBoxPropsCtor = {
    name: string;
    size?: number;
    width?: number;
    height?: number;
    depth?: number;
    faceUV?: BabylonjsCoreVector4[];
    faceColors?: BabylonjsCoreColor4[];
    sideOrientation?: number;
    frontUVs?: BabylonjsCoreVector4;
    backUVs?: BabylonjsCoreVector4;
    updatable?: boolean;
};
export declare type FiberTiledBoxPropsCtor = {
    name: string;
    pattern?: number;
    size?: number;
    width?: number;
    height?: number;
    depth?: number;
    tileSize?: number;
    tileWidth?: number;
    tileHeight?: number;
    faceUV?: BabylonjsCoreVector4[];
    faceColors?: BabylonjsCoreColor4[];
    alignHorizontal?: number;
    alignVertical?: number;
    sideOrientation?: number;
    updatable?: boolean;
};
export declare type FiberSpherePropsCtor = {
    name: string;
    segments?: number;
    diameter?: number;
    diameterX?: number;
    diameterY?: number;
    diameterZ?: number;
    arc?: number;
    slice?: number;
    sideOrientation?: number;
    frontUVs?: BabylonjsCoreVector4;
    backUVs?: BabylonjsCoreVector4;
    updatable?: boolean;
};
export declare type FiberDiscPropsCtor = {
    name: string;
    radius?: number;
    tessellation?: number;
    arc?: number;
    updatable?: boolean;
    sideOrientation?: number;
    frontUVs?: BabylonjsCoreVector4;
    backUVs?: BabylonjsCoreVector4;
};
export declare type FiberIcoSpherePropsCtor = {
    name: string;
    radius?: number;
    radiusX?: number;
    radiusY?: number;
    radiusZ?: number;
    flat?: boolean;
    subdivisions?: number;
    sideOrientation?: number;
    frontUVs?: BabylonjsCoreVector4;
    backUVs?: BabylonjsCoreVector4;
    updatable?: boolean;
};
export declare type FiberRibbonPropsCtor = {
    name: string;
    pathArray?: BabylonjsCoreVector3[][];
    closeArray?: boolean;
    closePath?: boolean;
    offset?: number;
    updatable?: boolean;
    sideOrientation?: number;
    frontUVs?: BabylonjsCoreVector4;
    backUVs?: BabylonjsCoreVector4;
    instance?: BabylonjsCoreMesh;
    invertUV?: boolean;
    uvs?: BabylonjsCoreVector2[];
    colors?: BabylonjsCoreColor4[];
};
export declare type FiberCylinderPropsCtor = {
    name: string;
    height?: number;
    diameterTop?: number;
    diameterBottom?: number;
    diameter?: number;
    tessellation?: number;
    subdivisions?: number;
    arc?: number;
    faceColors?: BabylonjsCoreColor4[];
    faceUV?: BabylonjsCoreVector4[];
    updatable?: boolean;
    hasRings?: boolean;
    enclose?: boolean;
    cap?: number;
    sideOrientation?: number;
    frontUVs?: BabylonjsCoreVector4;
    backUVs?: BabylonjsCoreVector4;
};
export declare type FiberTorusPropsCtor = {
    name: string;
    diameter?: number;
    thickness?: number;
    tessellation?: number;
    updatable?: boolean;
    sideOrientation?: number;
    frontUVs?: BabylonjsCoreVector4;
    backUVs?: BabylonjsCoreVector4;
};
export declare type FiberTorusKnotPropsCtor = {
    name: string;
    radius?: number;
    tube?: number;
    radialSegments?: number;
    tubularSegments?: number;
    p?: number;
    q?: number;
    updatable?: boolean;
    sideOrientation?: number;
    frontUVs?: BabylonjsCoreVector4;
    backUVs?: BabylonjsCoreVector4;
};
export declare type FiberLineSystemPropsCtor = {
    name: string;
    lines?: BabylonjsCoreVector3[][];
    updatable?: boolean;
    instance?: BabylonjsCoreLinesMesh;
    colors?: BabylonjsCoreColor4[][];
    useVertexAlpha?: boolean;
};
export declare type FiberLinesPropsCtor = {
    name: string;
    points?: BabylonjsCoreVector3[];
    updatable?: boolean;
    instance?: BabylonjsCoreLinesMesh;
    colors?: BabylonjsCoreColor4[];
    useVertexAlpha?: boolean;
};
export declare type FiberDashedLinesPropsCtor = {
    name: string;
    points?: BabylonjsCoreVector3[];
    dashSize?: number;
    gapSize?: number;
    dashNb?: number;
    updatable?: boolean;
    instance?: BabylonjsCoreLinesMesh;
};
export declare type FiberExtrudeShapePropsCtor = {
    name: string;
    shape?: BabylonjsCoreVector3[];
    path?: BabylonjsCoreVector3[];
    scale?: number;
    rotation?: number;
    cap?: number;
    updatable?: boolean;
    sideOrientation?: number;
    frontUVs?: BabylonjsCoreVector4;
    backUVs?: BabylonjsCoreVector4;
    instance?: BabylonjsCoreMesh;
    invertUV?: boolean;
};
export declare type FiberExtrudeShapeCustomPropsCtor = {
    name: string;
    shape?: BabylonjsCoreVector3[];
    path?: BabylonjsCoreVector3[];
    scaleFunction?: any;
    rotationFunction?: any;
    ribbonCloseArray?: boolean;
    ribbonClosePath?: boolean;
    cap?: number;
    updatable?: boolean;
    sideOrientation?: number;
    frontUVs?: BabylonjsCoreVector4;
    backUVs?: BabylonjsCoreVector4;
    instance?: BabylonjsCoreMesh;
    invertUV?: boolean;
};
export declare type FiberLathePropsCtor = {
    name: string;
    shape?: BabylonjsCoreVector3[];
    radius?: number;
    tessellation?: number;
    clip?: number;
    arc?: number;
    closed?: boolean;
    updatable?: boolean;
    sideOrientation?: number;
    frontUVs?: BabylonjsCoreVector4;
    backUVs?: BabylonjsCoreVector4;
    cap?: number;
    invertUV?: boolean;
};
export declare type FiberTiledPlanePropsCtor = {
    name: string;
    pattern?: number;
    tileSize?: number;
    tileWidth?: number;
    tileHeight?: number;
    size?: number;
    width?: number;
    height?: number;
    alignHorizontal?: number;
    alignVertical?: number;
    sideOrientation?: number;
    frontUVs?: BabylonjsCoreVector4;
    backUVs?: BabylonjsCoreVector4;
    updatable?: boolean;
};
export declare type FiberPlanePropsCtor = {
    name: string;
    size?: number;
    width?: number;
    height?: number;
    sideOrientation?: number;
    frontUVs?: BabylonjsCoreVector4;
    backUVs?: BabylonjsCoreVector4;
    updatable?: boolean;
    sourcePlane?: BabylonjsCorePlane;
};
export declare type FiberGroundPropsCtor = {
    name: string;
    width?: number;
    height?: number;
    subdivisions?: number;
    subdivisionsX?: number;
    subdivisionsY?: number;
    updatable?: boolean;
};
export declare type FiberTiledGroundPropsCtor = {
    name: string;
    xmin?: number;
    zmin?: number;
    xmax?: number;
    zmax?: number;
    subdivisions?: {
        w: number;
        h: number;
    };
    precision?: {
        w: number;
        h: number;
    };
    updatable?: boolean;
};
export declare type FiberGroundFromHeightMapPropsCtor = {
    name: string;
    url: string;
    width?: number;
    height?: number;
    subdivisions?: number;
    minHeight?: number;
    maxHeight?: number;
    colorFilter?: BabylonjsCoreColor3;
    alphaFilter?: number;
    updatable?: boolean;
    onReady?: (mesh: BabylonjsCoreGroundMesh) => void;
};
export declare type FiberPolygonPropsCtor = {
    name: string;
    shape?: BabylonjsCoreVector3[];
    holes?: BabylonjsCoreVector3[][];
    depth?: number;
    faceUV?: BabylonjsCoreVector4[];
    faceColors?: BabylonjsCoreColor4[];
    updatable?: boolean;
    sideOrientation?: number;
    frontUVs?: BabylonjsCoreVector4;
    backUVs?: BabylonjsCoreVector4;
    earcutInjection?: any;
};
export declare type FiberExtrudePolygonPropsCtor = {
    name: string;
    shape?: BabylonjsCoreVector3[];
    holes?: BabylonjsCoreVector3[][];
    depth?: number;
    faceUV?: BabylonjsCoreVector4[];
    faceColors?: BabylonjsCoreColor4[];
    updatable?: boolean;
    sideOrientation?: number;
    frontUVs?: BabylonjsCoreVector4;
    backUVs?: BabylonjsCoreVector4;
    earcutInjection?: any;
};
export declare type FiberTubePropsCtor = {
    name: string;
    path?: BabylonjsCoreVector3[];
    radius?: number;
    tessellation?: number;
    radiusFunction?: (i: number, distance: number) => number;
    cap?: number;
    arc?: number;
    updatable?: boolean;
    sideOrientation?: number;
    frontUVs?: BabylonjsCoreVector4;
    backUVs?: BabylonjsCoreVector4;
    instance?: BabylonjsCoreMesh;
    invertUV?: boolean;
};
export declare type FiberPolyhedronPropsCtor = {
    name: string;
    type?: number;
    size?: number;
    sizeX?: number;
    sizeY?: number;
    sizeZ?: number;
    custom?: any;
    faceUV?: BabylonjsCoreVector4[];
    faceColors?: BabylonjsCoreColor4[];
    flat?: boolean;
    updatable?: boolean;
    sideOrientation?: number;
    frontUVs?: BabylonjsCoreVector4;
    backUVs?: BabylonjsCoreVector4;
};
export declare type FiberDecalPropsCtor = {
    name: string;
    sourceMesh: BabylonjsCoreAbstractMesh;
    position?: BabylonjsCoreVector3;
    normal?: BabylonjsCoreVector3;
    size?: BabylonjsCoreVector3;
    angle?: number;
};
export declare type FiberMaterialProps = {
    alpha?: number;
    alphaMode?: number;
    animations?: BabylonjsCoreAnimation[];
    backFaceCulling?: boolean;
    checkReadyOnEveryCall?: boolean;
    checkReadyOnlyOnce?: boolean;
    depthFunction?: number;
    disableDepthWrite?: boolean;
    doNotSerialize?: boolean;
    fillMode?: number;
    fogEnabled?: boolean;
    forceDepthWrite?: boolean;
    getRenderTargetTextures?: () => BabylonjsCoreSmartArray<BabylonjsCoreRenderTargetTexture>;
    id?: string;
    inspectableCustomProperties?: BabylonjsCoreIInspectable[];
    meshMap?: {
        [id: string]: BabylonjsCoreAbstractMesh;
    };
    metadata?: any;
    name?: string;
    needDepthPrePass?: boolean;
    onBind?: (Mesh: BabylonjsCoreAbstractMesh) => void;
    onCompiled?: (effect: BabylonjsCoreEffect) => void;
    onDispose?: () => void;
    onDisposeObservable?: any;
    onError?: (effect: BabylonjsCoreEffect, errors: string) => void;
    pointsCloud?: boolean;
    pointSize?: number;
    releaseVertexArrayObject?: any;
    reservedDataStore?: any;
    separateCullingPass?: boolean;
    sideOrientation?: number;
    state?: string;
    uniqueId?: number;
    wireframe?: boolean;
    zOffset?: number;
} & CustomProps;
export declare type FiberMaterialPropsCtor = {
    name: string;
    doNotAdd?: boolean;
};
export declare type FiberShaderMaterialProps = {
    setArray2?: any;
    setArray3?: any;
    setArray4?: any;
    setColor3?: any;
    setColor3Array?: any;
    setColor4?: any;
    setColor4Array?: any;
    setFloat?: any;
    setFloats?: any;
    setInt?: any;
    setMatrices?: any;
    setMatrix?: any;
    setMatrix2x2?: any;
    setMatrix3x3?: any;
    setTexture?: any;
    setTextureArray?: any;
    setVector2?: any;
    setVector3?: any;
    setVector4?: any;
    shaderPath?: any;
} & FiberMaterialProps;
export declare type FiberShaderMaterialPropsCtor = {
    name: string;
    shaderPath: any;
    options?: Partial<BabylonjsCoreIShaderMaterialOptions>;
};
export declare type FiberMultiMaterialProps = {
    subMaterials?: BabylonjsCoreMaterial[];
} & FiberMaterialProps;
export declare type FiberMultiMaterialPropsCtor = {
    name: string;
};
export declare type FiberPushMaterialProps = {
    allowShaderHotSwapping?: boolean;
} & FiberMaterialProps;
export declare type FiberPushMaterialPropsCtor = {
    name: string;
};
export declare type FiberStandardMaterialProps = {
    alphaCutOff?: number;
    ambientColor?: BabylonjsCoreColor3;
    ambientTexture?: BabylonjsCoreBaseTexture;
    AmbientTextureEnabled?: boolean;
    bumpTexture?: BabylonjsCoreBaseTexture;
    BumpTextureEnabled?: boolean;
    cameraColorCurves?: BabylonjsCoreColorCurves;
    cameraColorCurvesEnabled?: boolean;
    cameraColorGradingEnabled?: boolean;
    cameraColorGradingTexture?: BabylonjsCoreBaseTexture;
    cameraContrast?: number;
    cameraExposure?: number;
    cameraToneMappingEnabled?: boolean;
    ColorGradingTextureEnabled?: boolean;
    customShaderNameResolve?: (shaderName: string, uniforms: string[], uniformBuffers: string[], samplers: string[], defines: BabylonjsCoreStandardMaterialDefines) => string;
    diffuseColor?: BabylonjsCoreColor3;
    diffuseFresnelParameters?: BabylonjsCoreFresnelParameters;
    diffuseTexture?: BabylonjsCoreBaseTexture;
    DiffuseTextureEnabled?: boolean;
    disableLighting?: boolean;
    emissiveColor?: BabylonjsCoreColor3;
    emissiveFresnelParameters?: BabylonjsCoreFresnelParameters;
    emissiveTexture?: BabylonjsCoreBaseTexture;
    EmissiveTextureEnabled?: boolean;
    FresnelEnabled?: boolean;
    imageProcessingConfiguration?: BabylonjsCoreImageProcessingConfiguration;
    indexOfRefraction?: number;
    invertNormalMapX?: boolean;
    invertNormalMapY?: boolean;
    invertRefractionY?: boolean;
    lightmapTexture?: BabylonjsCoreBaseTexture;
    LightmapTextureEnabled?: boolean;
    linkEmissiveWithDiffuse?: boolean;
    maxSimultaneousLights?: number;
    opacityFresnelParameters?: BabylonjsCoreFresnelParameters;
    opacityTexture?: BabylonjsCoreBaseTexture;
    OpacityTextureEnabled?: boolean;
    parallaxScaleBias?: number;
    reflectionFresnelParameters?: BabylonjsCoreFresnelParameters;
    reflectionTexture?: BabylonjsCoreBaseTexture;
    ReflectionTextureEnabled?: boolean;
    refractionFresnelParameters?: BabylonjsCoreFresnelParameters;
    refractionTexture?: BabylonjsCoreBaseTexture;
    RefractionTextureEnabled?: boolean;
    roughness?: number;
    specularColor?: BabylonjsCoreColor3;
    specularPower?: number;
    specularTexture?: BabylonjsCoreBaseTexture;
    SpecularTextureEnabled?: boolean;
    twoSidedLighting?: boolean;
    useAlphaFromDiffuseTexture?: boolean;
    useEmissiveAsIllumination?: boolean;
    useGlossinessFromSpecularMapAlpha?: boolean;
    useLightmapAsShadowmap?: boolean;
    useLogarithmicDepth?: boolean;
    useObjectSpaceNormalMap?: boolean;
    useParallax?: boolean;
    useParallaxOcclusion?: boolean;
    useReflectionFresnelFromSpecular?: boolean;
    useReflectionOverAlpha?: boolean;
    useSpecularOverAlpha?: boolean;
} & FiberPushMaterialProps;
export declare type FiberStandardMaterialPropsCtor = {
    name: string;
};
export declare type FiberBackgroundMaterialProps = {
    _perceptualColor?: BabylonjsCoreColor3;
    cameraColorCurves?: BabylonjsCoreColorCurves;
    cameraColorCurvesEnabled?: boolean;
    cameraColorGradingEnabled?: boolean;
    cameraColorGradingTexture?: BabylonjsCoreBaseTexture;
    cameraContrast?: number;
    cameraExposure?: number;
    cameraToneMappingEnabled?: boolean;
    diffuseTexture?: BabylonjsCoreBaseTexture;
    enableNoise?: boolean;
    fovMultiplier?: number;
    imageProcessingConfiguration?: BabylonjsCoreImageProcessingConfiguration;
    maxSimultaneousLights?: number;
    opacityFresnel?: boolean;
    primaryColor?: BabylonjsCoreColor3;
    primaryColorHighlightLevel?: number;
    primaryColorShadowLevel?: number;
    reflectionAmount?: number;
    reflectionBlur?: number;
    reflectionFalloffDistance?: number;
    reflectionFresnel?: boolean;
    reflectionReflectance0?: number;
    reflectionReflectance90?: number;
    reflectionStandardFresnelWeight?: number;
    reflectionTexture?: BabylonjsCoreBaseTexture;
    sceneCenter?: BabylonjsCoreVector3;
    shadowLevel?: number;
    shadowLights?: BabylonjsCoreIShadowLight[];
    switchToBGR?: boolean;
    useEquirectangularFOV?: boolean;
    useRGBColor?: boolean;
} & FiberPushMaterialProps;
export declare type FiberBackgroundMaterialPropsCtor = {
    name: string;
};
export declare type FiberPBRBaseMaterialProps = {
    customShaderNameResolve?: (shaderName: string, uniforms: string[], uniformBuffers: string[], samplers: string[], defines: BabylonjsCorePBRMaterialDefines) => string;
    debugFactor?: any;
    debugLimit?: any;
    debugMode?: number;
    transparencyMode?: number;
    useLogarithmicDepth?: boolean;
} & FiberPushMaterialProps;
export declare type FiberPBRBaseMaterialPropsCtor = {
    name: string;
};
export declare type FiberPBRBaseSimpleMaterialProps = {
    alphaCutOff?: number;
    disableLighting?: boolean;
    doubleSided?: boolean;
    emissiveColor?: BabylonjsCoreColor3;
    emissiveTexture?: BabylonjsCoreBaseTexture;
    environmentTexture?: BabylonjsCoreBaseTexture;
    invertNormalMapX?: boolean;
    invertNormalMapY?: boolean;
    lightmapTexture?: BabylonjsCoreBaseTexture;
    maxSimultaneousLights?: number;
    normalTexture?: BabylonjsCoreBaseTexture;
    occlusionStrength?: number;
    occlusionTexture?: BabylonjsCoreBaseTexture;
    useLightmapAsShadowmap?: boolean;
} & FiberPBRBaseMaterialProps;
export declare type FiberPBRBaseSimpleMaterialPropsCtor = {
    name: string;
};
export declare type FiberPBRMetallicRoughnessMaterialProps = {
    baseColor?: BabylonjsCoreColor3;
    baseTexture?: BabylonjsCoreBaseTexture;
    metallic?: number;
    metallicRoughnessTexture?: BabylonjsCoreBaseTexture;
    roughness?: number;
} & FiberPBRBaseSimpleMaterialProps;
export declare type FiberPBRMetallicRoughnessMaterialPropsCtor = {
    name: string;
};
export declare type FiberPBRSpecularGlossinessMaterialProps = {
    diffuseColor?: BabylonjsCoreColor3;
    diffuseTexture?: BabylonjsCoreBaseTexture;
    glossiness?: number;
    specularColor?: BabylonjsCoreColor3;
    specularGlossinessTexture?: BabylonjsCoreBaseTexture;
} & FiberPBRBaseSimpleMaterialProps;
export declare type FiberPBRSpecularGlossinessMaterialPropsCtor = {
    name: string;
};
export declare type FiberPBRMaterialProps = {
    albedoColor?: BabylonjsCoreColor3;
    albedoTexture?: BabylonjsCoreBaseTexture;
    alphaCutOff?: number;
    ambientColor?: BabylonjsCoreColor3;
    ambientTexture?: BabylonjsCoreBaseTexture;
    ambientTextureImpactOnAnalyticalLights?: number;
    ambientTextureStrength?: number;
    bumpTexture?: BabylonjsCoreBaseTexture;
    cameraColorCurves?: BabylonjsCoreColorCurves;
    cameraColorCurvesEnabled?: boolean;
    cameraColorGradingEnabled?: boolean;
    cameraColorGradingTexture?: BabylonjsCoreBaseTexture;
    cameraContrast?: number;
    cameraExposure?: number;
    cameraToneMappingEnabled?: boolean;
    directIntensity?: number;
    disableBumpMap?: boolean;
    disableLighting?: boolean;
    emissiveColor?: BabylonjsCoreColor3;
    emissiveIntensity?: number;
    emissiveTexture?: BabylonjsCoreBaseTexture;
    enableSpecularAntiAliasing?: boolean;
    environmentBRDFTexture?: BabylonjsCoreBaseTexture;
    environmentIntensity?: number;
    forceAlphaTest?: boolean;
    forceIrradianceInFragment?: boolean;
    forceNormalForward?: boolean;
    imageProcessingConfiguration?: BabylonjsCoreImageProcessingConfiguration;
    indexOfRefraction?: number;
    invertNormalMapX?: boolean;
    invertNormalMapY?: boolean;
    invertRefractionY?: boolean;
    lightmapTexture?: BabylonjsCoreBaseTexture;
    linkRefractionWithTransparency?: boolean;
    maxSimultaneousLights?: number;
    metallic?: number;
    metallicF0Factor?: number;
    metallicTexture?: BabylonjsCoreBaseTexture;
    microSurface?: number;
    microSurfaceTexture?: BabylonjsCoreBaseTexture;
    opacityTexture?: BabylonjsCoreBaseTexture;
    parallaxScaleBias?: number;
    reflectionColor?: BabylonjsCoreColor3;
    reflectionTexture?: BabylonjsCoreBaseTexture;
    reflectivityColor?: BabylonjsCoreColor3;
    reflectivityTexture?: BabylonjsCoreBaseTexture;
    refractionTexture?: BabylonjsCoreBaseTexture;
    roughness?: number;
    specularIntensity?: number;
    twoSidedLighting?: boolean;
    unlit?: boolean;
    useAlphaFresnel?: boolean;
    useAlphaFromAlbedoTexture?: boolean;
    useAmbientInGrayScale?: boolean;
    useAmbientOcclusionFromMetallicTextureRed?: boolean;
    useAutoMicroSurfaceFromReflectivityMap?: boolean;
    useGLTFLightFalloff?: boolean;
    useHorizonOcclusion?: boolean;
    useLightmapAsShadowmap?: boolean;
    useLinearAlphaFresnel?: boolean;
    useMetallicF0FactorFromMetallicTexture?: boolean;
    useMetallnessFromMetallicTextureBlue?: boolean;
    useMicroSurfaceFromReflectivityMapAlpha?: boolean;
    useObjectSpaceNormalMap?: boolean;
    useParallax?: boolean;
    useParallaxOcclusion?: boolean;
    usePhysicalLightFalloff?: boolean;
    useRadianceOcclusion?: boolean;
    useRadianceOverAlpha?: boolean;
    useRoughnessFromMetallicTextureAlpha?: boolean;
    useRoughnessFromMetallicTextureGreen?: boolean;
    useSpecularOverAlpha?: boolean;
} & FiberPBRBaseMaterialProps;
export declare type FiberPBRMaterialPropsCtor = {
    name: string;
};
export declare type FiberNodeMaterialProps = {
    addOutputNode?: any;
    attachedBlocks?: BabylonjsCoreNodeMaterialBlock[];
    BJSNODEMATERIALEDITOR?: any;
    editorData?: any;
    ignoreAlpha?: boolean;
    imageProcessingConfiguration?: BabylonjsCoreImageProcessingConfiguration;
    maxSimultaneousLights?: number;
    onBuildObservable?: any;
    options?: BabylonjsCoreINodeMaterialOptions;
} & FiberPushMaterialProps;
export declare type FiberNodeMaterialPropsCtor = {
    name: string;
    options?: Partial<BabylonjsCoreINodeMaterialOptions>;
};
export declare type FiberFluentMaterialProps = {
    albedoColor?: BabylonjsCoreColor3;
    albedoTexture?: BabylonjsCoreBaseTexture;
    alpha?: number;
    borderMinValue?: number;
    borderWidth?: number;
    edgeSmoothingValue?: number;
    hoverColor?: BabylonjsCoreColor4;
    hoverPosition?: BabylonjsCoreVector3;
    hoverRadius?: number;
    innerGlowColor?: BabylonjsCoreColor3;
    innerGlowColorIntensity?: number;
    renderBorders?: boolean;
    renderHoverLight?: boolean;
} & FiberPushMaterialProps;
export declare type FiberFluentMaterialPropsCtor = {
    name: string;
};
export declare type FiberLightProps = {
    diffuse?: BabylonjsCoreColor3;
    excludedMeshes?: BabylonjsCoreAbstractMesh[];
    excludeWithLayerMask?: number;
    falloffType?: number;
    includedOnlyMeshes?: BabylonjsCoreAbstractMesh[];
    includeOnlyWithLayerMask?: number;
    intensity?: number;
    intensityMode?: number;
    lightmapMode?: number;
    radius?: number;
    range?: number;
    renderPriority?: number;
    setEnabled?: any;
    shadowEnabled?: boolean;
    specular?: BabylonjsCoreColor3;
} & FiberNodeProps;
export declare type FiberLightPropsCtor = {
    name: string;
};
export declare type FiberShadowLightProps = {
    customProjectionMatrixBuilder?: (viewMatrix: BabylonjsCoreMatrix, renderList: BabylonjsCoreAbstractMesh[], result: BabylonjsCoreMatrix) => void;
    direction?: BabylonjsCoreVector3;
    position?: BabylonjsCoreVector3;
    setDirectionToTarget?: any;
    setShadowProjectionMatrix?: any;
    shadowMaxZ?: number;
    shadowMinZ?: number;
    transformedDirection?: BabylonjsCoreVector3;
    transformedPosition?: BabylonjsCoreVector3;
} & FiberLightProps;
export declare type FiberShadowLightPropsCtor = {};
export declare type FiberDirectionalLightProps = {
    autoCalcShadowZBounds?: boolean;
    autoUpdateExtends?: boolean;
    shadowFrustumSize?: number;
    shadowOrthoScale?: number;
} & FiberShadowLightProps;
export declare type FiberDirectionalLightPropsCtor = {
    name: string;
    direction: BabylonjsCoreVector3;
};
export declare type FiberPointLightProps = {
    direction?: BabylonjsCoreVector3;
    shadowAngle?: number;
} & FiberShadowLightProps;
export declare type FiberPointLightPropsCtor = {
    name: string;
    position: BabylonjsCoreVector3;
};
export declare type FiberSpotLightProps = {
    angle?: number;
    exponent?: number;
    innerAngle?: number;
    projectionTexture?: BabylonjsCoreBaseTexture;
    projectionTextureLightFar?: number;
    projectionTextureLightNear?: number;
    projectionTextureUpDirection?: BabylonjsCoreVector3;
    shadowAngleScale?: number;
} & FiberShadowLightProps;
export declare type FiberSpotLightPropsCtor = {
    name: string;
    position: BabylonjsCoreVector3;
    direction: BabylonjsCoreVector3;
    angle: number;
    exponent: number;
};
export declare type FiberHemisphericLightProps = {
    direction?: BabylonjsCoreVector3;
    groundColor?: BabylonjsCoreColor3;
    setDirectionToTarget?: any;
} & FiberLightProps;
export declare type FiberHemisphericLightPropsCtor = {
    name: string;
    direction: BabylonjsCoreVector3;
};
export declare type FiberControlProps = {
    alpha?: number;
    clipChildren?: boolean;
    clipContent?: boolean;
    color?: string;
    disabledColor?: string;
    disabledColorItem?: string;
    fontFamily?: string;
    fontOffset?: {
        ascent: number;
        height: number;
        descent: number;
    };
    fontSize?: string | number;
    fontSizeInPixels?: number;
    fontStyle?: string;
    fontWeight?: string;
    height?: string | number;
    heightInPixels?: number;
    horizontalAlignment?: number;
    hoverCursor?: string;
    isEnabled?: boolean;
    isFocusInvisible?: boolean;
    isHighlighted?: boolean;
    isHitTestVisible?: boolean;
    isPointerBlocker?: boolean;
    isVisible?: boolean;
    left?: string | number;
    leftInPixels?: number;
    linkOffsetX?: string | number;
    linkOffsetXInPixels?: number;
    linkOffsetY?: string | number;
    linkOffsetYInPixels?: number;
    metadata?: any;
    name?: string;
    notRenderable?: boolean;
    onAfterDrawObservable?: any;
    onBeforeDrawObservable?: any;
    onDirtyObservable?: any;
    onPointerClickObservable?: any;
    onPointerDownObservable?: any;
    onPointerEnterObservable?: any;
    onPointerMoveObservable?: any;
    onPointerOutObservable?: any;
    onPointerUpObservable?: any;
    onWheelObservable?: any;
    paddingBottom?: string | number;
    paddingBottomInPixels?: number;
    paddingLeft?: string | number;
    paddingLeftInPixels?: number;
    paddingRight?: string | number;
    paddingRightInPixels?: number;
    paddingTop?: string | number;
    paddingTopInPixels?: number;
    parent?: BabylonjsGuiContainer;
    rotation?: number;
    scaleX?: number;
    scaleY?: number;
    shadowBlur?: number;
    shadowColor?: string;
    shadowOffsetX?: number;
    shadowOffsetY?: number;
    style?: BabylonjsGuiStyle;
    top?: string | number;
    topInPixels?: number;
    transformCenterX?: number;
    transformCenterY?: number;
    uniqueId?: number;
    useBitmapCache?: boolean;
    verticalAlignment?: number;
    width?: string | number;
    widthInPixels?: number;
    zIndex?: number;
} & CustomProps;
export declare type FiberControlPropsCtor = {
    name?: string;
};
export declare type FiberContainerProps = {
    adaptHeightToChildren?: boolean;
    adaptWidthToChildren?: boolean;
    addControl?: any;
    background?: string;
    logLayoutCycleErrors?: boolean;
    maxLayoutCycle?: number;
    name?: string;
} & FiberControlProps;
export declare type FiberContainerPropsCtor = {
    name?: string;
};
export declare type FiberRectangleProps = {
    cornerRadius?: number;
    name?: string;
    thickness?: number;
} & FiberContainerProps;
export declare type FiberRectanglePropsCtor = {
    name?: string;
};
export declare type FiberButtonProps = {
    delegatePickingToChildren?: boolean;
    name?: string;
    pointerDownAnimation?: () => void;
    pointerEnterAnimation?: () => void;
    pointerOutAnimation?: () => void;
    pointerUpAnimation?: () => void;
} & FiberRectangleProps;
export declare type FiberButtonPropsCtor = {
    name?: string;
};
export declare type FiberSelectionPanelProps = {
    addGroup?: any;
    addToGroupCheckbox?: any;
    addToGroupRadio?: any;
    addToGroupSlider?: any;
    barColor?: string;
    barHeight?: string;
    buttonBackground?: string;
    buttonColor?: string;
    groups?: BabylonjsGuiSelectorGroup[];
    headerColor?: string;
    labelColor?: string;
    name?: string;
    setHeaderName?: any;
    spacerHeight?: string;
} & FiberRectangleProps;
export declare type FiberSelectionPanelPropsCtor = {
    name: string;
    groups?: BabylonjsGuiSelectorGroup[];
};
export declare type FiberScrollViewerProps = {
    addControl?: any;
    barBackground?: string;
    barColor?: string;
    barImage?: BabylonjsGuiImage;
    barImageHeight?: number;
    barSize?: number;
    forceHorizontalBar?: boolean;
    forceVerticalBar?: boolean;
    freezeControls?: boolean;
    horizontalBarImage?: BabylonjsGuiImage;
    horizontalBarImageHeight?: number;
    horizontalThumbImage?: BabylonjsGuiImage;
    scrollBackground?: string;
    setBucketSizes?: any;
    thumbHeight?: number;
    thumbImage?: BabylonjsGuiImage;
    thumbLength?: number;
    verticalBarImage?: BabylonjsGuiImage;
    verticalBarImageHeight?: number;
    verticalThumbImage?: BabylonjsGuiImage;
    wheelPrecision?: number;
} & FiberRectangleProps;
export declare type FiberScrollViewerPropsCtor = {
    name?: string;
    isImageBased?: boolean;
};
export declare type FiberStackPanelProps = {
    height?: string | number;
    ignoreLayoutWarnings?: boolean;
    isVertical?: boolean;
    name?: string;
    width?: string | number;
} & FiberContainerProps;
export declare type FiberStackPanelPropsCtor = {
    name?: string;
};
export declare type FiberVirtualKeyboardProps = {
    addKeysRow?: any;
    defaultButtonBackground?: string;
    defaultButtonColor?: string;
    defaultButtonHeight?: string;
    defaultButtonPaddingBottom?: string;
    defaultButtonPaddingLeft?: string;
    defaultButtonPaddingRight?: string;
    defaultButtonPaddingTop?: string;
    defaultButtonWidth?: string;
    onKeyPressObservable?: any;
    selectedShiftThickness?: number;
    shiftButtonColor?: string;
    shiftState?: number;
} & FiberStackPanelProps;
export declare type FiberVirtualKeyboardPropsCtor = {};
export declare type FiberEllipseProps = {
    name?: string;
    thickness?: number;
} & FiberContainerProps;
export declare type FiberEllipsePropsCtor = {
    name?: string;
};
export declare type FiberGridProps = {
    addColumnDefinition?: any;
    addControl?: any;
    addRowDefinition?: any;
    name?: string;
    setColumnDefinition?: any;
    setRowDefinition?: any;
} & FiberContainerProps;
export declare type FiberGridPropsCtor = {
    name?: string;
};
export declare type Fiber_ScrollViewerWindowProps = {
    freezeControls?: boolean;
    parentClientHeight?: number;
    parentClientWidth?: number;
    setBucketSizes?: any;
} & FiberContainerProps;
export declare type Fiber_ScrollViewerWindowPropsCtor = {
    name?: string;
};
export declare type FiberTextBlockProps = {
    lineSpacing?: string | number;
    name?: string;
    onLinesReadyObservable?: any;
    onTextChangedObservable?: any;
    outlineColor?: string;
    outlineWidth?: number;
    resizeToFit?: boolean;
    text?: string;
    textHorizontalAlignment?: number;
    textVerticalAlignment?: number;
    textWrapping?: boolean | BabylonjsGuiTextWrapping;
} & FiberControlProps;
export declare type FiberTextBlockPropsCtor = {
    name?: string;
    text?: string;
};
export declare type FiberImageProps = {
    autoScale?: boolean;
    cellHeight?: number;
    cellId?: number;
    cellWidth?: number;
    detectPointerOnOpaqueOnly?: boolean;
    domImage?: HTMLImageElement;
    name?: string;
    onImageLoadedObservable?: any;
    onSVGAttributesComputedObservable?: any;
    populateNinePatchSlicesFromImage?: boolean;
    sliceBottom?: number;
    sliceLeft?: number;
    sliceRight?: number;
    sliceTop?: number;
    source?: string;
    sourceHeight?: number;
    sourceLeft?: number;
    sourceTop?: number;
    sourceWidth?: number;
    stretch?: number;
} & FiberControlProps;
export declare type FiberImagePropsCtor = {
    name?: string;
    url?: string;
};
export declare type FiberCheckboxProps = {
    background?: string;
    checkSizeRatio?: number;
    isChecked?: boolean;
    name?: string;
    onIsCheckedChangedObservable?: any;
    thickness?: number;
} & FiberControlProps;
export declare type FiberCheckboxPropsCtor = {
    name?: string;
};
export declare type FiberColorPickerProps = {
    height?: string | number;
    name?: string;
    onValueChangedObservable?: any;
    size?: string | number;
    value?: BabylonjsCoreColor3;
    width?: string | number;
} & FiberControlProps;
export declare type FiberColorPickerPropsCtor = {
    name?: string;
};
export declare type FiberInputTextProps = {
    addKey?: boolean;
    autoStretchWidth?: boolean;
    background?: string;
    currentKey?: string;
    deadKey?: boolean;
    disableMobilePrompt?: boolean;
    focusedBackground?: string;
    focusedColor?: string;
    highligherOpacity?: number;
    highlightedText?: string;
    margin?: string;
    maxWidth?: string | number;
    name?: string;
    onBeforeKeyAddObservable?: any;
    onBlurObservable?: any;
    onFocusObservable?: any;
    onFocusSelectAll?: boolean;
    onKeyboardEventProcessedObservable?: any;
    onTextChangedObservable?: any;
    onTextCopyObservable?: any;
    onTextCutObservable?: any;
    onTextHighlightObservable?: any;
    onTextPasteObservable?: any;
    placeholderColor?: string;
    placeholderText?: string;
    promptMessage?: string;
    text?: string;
    textHighlightColor?: string;
    thickness?: number;
    width?: string | number;
} & FiberControlProps;
export declare type FiberInputTextPropsCtor = {
    name?: string;
    text?: string;
};
export declare type FiberInputPasswordProps = {} & FiberInputTextProps;
export declare type FiberInputPasswordPropsCtor = {};
export declare type FiberLineProps = {
    connectedControl?: BabylonjsGuiControl;
    dash?: number[];
    horizontalAlignment?: number;
    lineWidth?: number;
    name?: string;
    verticalAlignment?: number;
    x1?: string | number;
    x2?: string | number;
    y1?: string | number;
    y2?: string | number;
} & FiberControlProps;
export declare type FiberLinePropsCtor = {
    name?: string;
};
export declare type FiberMultiLineProps = {
    add?: any;
    dash?: number[];
    horizontalAlignment?: number;
    lineWidth?: number;
    name?: string;
    onPointUpdate?: () => void;
    verticalAlignment?: number;
} & FiberControlProps;
export declare type FiberMultiLinePropsCtor = {
    name?: string;
};
export declare type FiberRadioButtonProps = {
    background?: string;
    checkSizeRatio?: number;
    group?: string;
    isChecked?: boolean;
    name?: string;
    onIsCheckedChangedObservable?: any;
    thickness?: number;
} & FiberControlProps;
export declare type FiberRadioButtonPropsCtor = {
    name?: string;
};
export declare type FiberBaseSliderProps = {
    barOffset?: string | number;
    displayThumb?: boolean;
    isThumbClamped?: boolean;
    isVertical?: boolean;
    maximum?: number;
    minimum?: number;
    name?: string;
    onValueChangedObservable?: any;
    step?: number;
    thumbWidth?: string | number;
    value?: number;
} & FiberControlProps;
export declare type FiberBaseSliderPropsCtor = {
    name?: string;
};
export declare type FiberScrollBarProps = {
    background?: string;
    borderColor?: string;
    name?: string;
} & FiberBaseSliderProps;
export declare type FiberScrollBarPropsCtor = {
    name?: string;
};
export declare type FiberImageScrollBarProps = {
    backgroundImage?: BabylonjsGuiImage;
    barImageHeight?: number;
    name?: string;
    num90RotationInVerticalMode?: number;
    thumbHeight?: number;
    thumbImage?: BabylonjsGuiImage;
    thumbLength?: number;
} & FiberBaseSliderProps;
export declare type FiberImageScrollBarPropsCtor = {
    name?: string;
};
export declare type FiberSliderProps = {
    background?: string;
    borderColor?: string;
    displayValueBar?: boolean;
    isThumbCircle?: boolean;
    name?: string;
} & FiberBaseSliderProps;
export declare type FiberSliderPropsCtor = {
    name?: string;
};
export declare type FiberImageBasedSliderProps = {
    backgroundImage?: BabylonjsGuiImage;
    displayThumb?: boolean;
    name?: string;
    thumbImage?: BabylonjsGuiImage;
    valueBarImage?: BabylonjsGuiImage;
} & FiberBaseSliderProps;
export declare type FiberImageBasedSliderPropsCtor = {
    name?: string;
};
export declare type FiberDisplayGridProps = {
    background?: string;
    cellHeight?: number;
    cellWidth?: number;
    displayMajorLines?: boolean;
    displayMinorLines?: boolean;
    majorLineColor?: string;
    majorLineFrequency?: number;
    majorLineTickness?: number;
    minorLineColor?: string;
    minorLineTickness?: number;
    name?: string;
} & FiberControlProps;
export declare type FiberDisplayGridPropsCtor = {
    name?: string;
};
export declare type FiberControl3DProps = {
    addBehavior?: any;
    isVisible?: boolean;
    name?: string;
    onPointerClickObservable?: any;
    onPointerDownObservable?: any;
    onPointerEnterObservable?: any;
    onPointerMoveObservable?: any;
    onPointerOutObservable?: any;
    onPointerUpObservable?: any;
    parent?: BabylonjsGuiContainer3D;
    pointerDownAnimation?: () => void;
    pointerEnterAnimation?: () => void;
    pointerOutAnimation?: () => void;
    pointerUpAnimation?: () => void;
    position?: BabylonjsCoreVector3;
    scaling?: BabylonjsCoreVector3;
} & CustomProps;
export declare type FiberControl3DPropsCtor = {
    name?: string;
};
export declare type FiberContainer3DProps = {
    addControl?: any;
    blockLayout?: boolean;
} & FiberControl3DProps;
export declare type FiberContainer3DPropsCtor = {
    name?: string;
};
export declare type FiberVolumeBasedPanelProps = {
    columns?: number;
    margin?: number;
    orientation?: number;
    rows?: number;
} & FiberContainer3DProps;
export declare type FiberVolumeBasedPanelPropsCtor = {};
export declare type FiberCylinderPanelProps = {
    radius?: number;
} & FiberVolumeBasedPanelProps;
export declare type FiberCylinderPanelPropsCtor = {};
export declare type FiberPlanePanelProps = {} & FiberVolumeBasedPanelProps;
export declare type FiberPlanePanelPropsCtor = {};
export declare type FiberScatterPanelProps = {
    iteration?: number;
} & FiberVolumeBasedPanelProps;
export declare type FiberScatterPanelPropsCtor = {};
export declare type FiberSpherePanelProps = {
    radius?: number;
} & FiberVolumeBasedPanelProps;
export declare type FiberSpherePanelPropsCtor = {};
export declare type FiberStackPanel3DProps = {
    isVertical?: boolean;
    margin?: number;
} & FiberContainer3DProps;
export declare type FiberStackPanel3DPropsCtor = {
    isVertical?: boolean;
};
export declare type FiberAbstractButton3DProps = {} & FiberControl3DProps;
export declare type FiberAbstractButton3DPropsCtor = {
    name?: string;
};
export declare type FiberButton3DProps = {
    content?: BabylonjsGuiControl;
    contentResolution?: number;
    contentScaleRatio?: number;
} & FiberAbstractButton3DProps;
export declare type FiberButton3DPropsCtor = {
    name?: string;
};
export declare type FiberHolographicButtonProps = {
    imageUrl?: string;
    renderingGroupId?: number;
    text?: string;
    tooltipText?: string;
} & FiberButton3DProps;
export declare type FiberHolographicButtonPropsCtor = {
    name?: string;
    shareMaterials?: boolean;
};
export declare type FiberMeshButton3DProps = {} & FiberButton3DProps;
export declare type FiberMeshButton3DPropsCtor = {
    mesh: BabylonjsCoreMesh;
    name?: string;
};
export declare type FiberEffectLayerProps = {
    isEnabled?: boolean;
    name?: string;
    neutralColor?: BabylonjsCoreColor4;
    onAfterComposeObservable?: any;
    onAfterRenderMeshToEffect?: any;
    onBeforeComposeObservable?: any;
    onBeforeRenderMainTextureObservable?: any;
    onBeforeRenderMeshToEffect?: any;
    onDisposeObservable?: any;
    onSizeChangedObservable?: any;
    renderingGroupId?: number;
} & CustomProps;
export declare type FiberEffectLayerPropsCtor = {
    name: string;
};
export declare type FiberGlowLayerProps = {
    addExcludedMesh?: any;
    addIncludedOnlyMesh?: any;
    blurKernelSize?: number;
    customEmissiveColorSelector?: (mesh: BabylonjsCoreMesh, subMesh: BabylonjsCoreSubMesh, material: BabylonjsCoreMaterial, result: BabylonjsCoreColor4) => void;
    customEmissiveTextureSelector?: (mesh: BabylonjsCoreMesh, subMesh: BabylonjsCoreSubMesh, material: BabylonjsCoreMaterial) => BabylonjsCoreTexture;
    intensity?: number;
} & FiberEffectLayerProps;
export declare type FiberGlowLayerPropsCtor = {
    name: string;
    options?: Partial<BabylonjsCoreIGlowLayerOptions>;
};
export declare type FiberHighlightLayerProps = {
    addExcludedMesh?: any;
    addMesh?: any;
    blurHorizontalSize?: number;
    blurVerticalSize?: number;
    innerGlow?: boolean;
    name?: string;
    onAfterBlurObservable?: any;
    onBeforeBlurObservable?: any;
    outerGlow?: boolean;
} & FiberEffectLayerProps;
export declare type FiberHighlightLayerPropsCtor = {
    name: string;
    options?: Partial<BabylonjsCoreIHighlightLayerOptions>;
};
export declare type FiberBaseTextureProps = {
    animations?: BabylonjsCoreAnimation[];
    anisotropicFilteringLevel?: number;
    coordinatesIndex?: number;
    coordinatesMode?: number;
    delayLoadState?: number;
    gammaSpace?: boolean;
    getAlphaFromRGB?: boolean;
    hasAlpha?: boolean;
    invertZ?: boolean;
    irradianceTexture?: BabylonjsCoreBaseTexture;
    is2DArray?: boolean;
    is3D?: boolean;
    isCube?: boolean;
    isRenderTarget?: boolean;
    isRGBD?: boolean;
    level?: number;
    linearSpecularLOD?: boolean;
    lodGenerationOffset?: number;
    lodGenerationScale?: number;
    lodLevelInAlpha?: boolean;
    metadata?: any;
    name?: string;
    onDispose?: () => void;
    onDisposeObservable?: any;
    reservedDataStore?: any;
    uniqueId?: number;
    wrapR?: number;
    wrapU?: number;
    wrapV?: number;
} & CustomProps;
export declare type FiberBaseTexturePropsCtor = {};
export declare type FiberCubeTextureProps = {
    boundingBoxPosition?: BabylonjsCoreVector3;
    boundingBoxSize?: BabylonjsCoreVector3;
    onLoadObservable?: any;
    rotationY?: number;
    setReflectionTextureMatrix?: any;
    url?: string;
} & FiberBaseTextureProps;
export declare type FiberCubeTexturePropsCtor = {
    rootUrl: string;
    extensions?: string[];
    noMipmap?: boolean;
    files?: string[];
    onLoad?: () => void;
    onError?: (message?: string, exception?: any) => void;
    format?: number;
    prefiltered?: boolean;
    forcedExtension?: any;
    createPolynomials?: boolean;
    lodScale?: number;
    lodOffset?: number;
};
export declare type FiberRawCubeTextureProps = {} & FiberCubeTextureProps;
export declare type FiberRawCubeTexturePropsCtor = {
    data: ArrayBufferView[];
    size: number;
    format?: number;
    type?: number;
    generateMipMaps?: boolean;
    invertY?: boolean;
    samplingMode?: number;
    compression?: string;
};
export declare type FiberTextureProps = {
    inspectableCustomProperties?: BabylonjsCoreIInspectable[];
    isBlocking?: boolean;
    onLoadObservable?: any;
    uAng?: number;
    uOffset?: number;
    url?: string;
    uRotationCenter?: number;
    uScale?: number;
    vAng?: number;
    vOffset?: number;
    vRotationCenter?: number;
    vScale?: number;
    wAng?: number;
    wRotationCenter?: number;
} & FiberBaseTextureProps;
export declare type FiberTexturePropsCtor = {
    url: string;
    noMipmap?: boolean;
    invertY?: boolean;
    samplingMode?: number;
    onLoad?: () => void;
    onError?: (message?: string, exception?: any) => void;
    buffer?: string | HTMLImageElement | ArrayBufferView | ArrayBuffer | Blob | ImageBitmap;
    deleteBuffer?: boolean;
    format?: number;
    mimeType?: string;
};
export declare type FiberRawTextureProps = {
    format?: number;
} & FiberTextureProps;
export declare type FiberRawTexturePropsCtor = {
    data: ArrayBufferView;
    width: number;
    height: number;
    format: number;
    generateMipMaps?: boolean;
    invertY?: boolean;
    samplingMode?: number;
    type?: number;
};
export declare type FiberProceduralTextureProps = {
    autoClear?: boolean;
    isCube?: boolean;
    isEnabled?: boolean;
    onGenerated?: () => void;
    onGeneratedObservable?: any;
    refreshRate?: number;
    setColor3?: any;
    setColor4?: any;
    setFloat?: any;
    setFloats?: any;
    setFragment?: any;
    setInt?: any;
    setMatrix?: any;
    setTexture?: any;
    setVector2?: any;
    setVector3?: any;
} & FiberTextureProps;
export declare type FiberProceduralTexturePropsCtor = {
    name: string;
    size: any;
    fragment: any;
    fallbackTexture?: BabylonjsCoreTexture;
    generateMipMaps?: boolean;
    isCube?: boolean;
};
export declare type FiberCustomProceduralTextureProps = {
    animate?: boolean;
} & FiberProceduralTextureProps;
export declare type FiberCustomProceduralTexturePropsCtor = {
    name: string;
    texturePath: string;
    size: number;
    fallbackTexture?: BabylonjsCoreTexture;
    generateMipMaps?: boolean;
};
export declare type FiberNoiseProceduralTextureProps = {
    animationSpeedFactor?: number;
    brightness?: number;
    octaves?: number;
    persistence?: number;
} & FiberProceduralTextureProps;
export declare type FiberNoiseProceduralTexturePropsCtor = {
    name: string;
    size?: number;
    fallbackTexture?: BabylonjsCoreTexture;
    generateMipMaps?: boolean;
};
export declare type FiberRenderTargetTextureProps = {
    activeCamera?: BabylonjsCoreCamera;
    addPostProcess?: any;
    boundingBoxPosition?: BabylonjsCoreVector3;
    boundingBoxSize?: BabylonjsCoreVector3;
    clearColor?: BabylonjsCoreColor4;
    coordinatesMode?: number;
    customRenderFunction?: (opaqueSubMeshes: BabylonjsCoreSmartArray<BabylonjsCoreSubMesh>, alphaTestSubMeshes: BabylonjsCoreSmartArray<BabylonjsCoreSubMesh>, transparentSubMeshes: BabylonjsCoreSmartArray<BabylonjsCoreSubMesh>, depthOnlySubMeshes: BabylonjsCoreSmartArray<BabylonjsCoreSubMesh>, beforeTransparents?: () => void) => void;
    getCustomRenderList?: (layerOrFace: number, renderList: readonly BabylonjsCoreAbstractMesh[], renderListLength: number) => BabylonjsCoreAbstractMesh[];
    ignoreCameraViewport?: boolean;
    isCube?: boolean;
    onAfterRender?: (faceIndex: number) => void;
    onAfterRenderObservable?: any;
    onAfterUnbind?: () => void;
    onAfterUnbindObservable?: any;
    onBeforeBindObservable?: any;
    onBeforeRender?: (faceIndex: number) => void;
    onBeforeRenderObservable?: any;
    onClear?: (Engine: BabylonjsCoreEngine) => void;
    onClearObservable?: any;
    onResizeObservable?: any;
    refreshRate?: number;
    renderList?: BabylonjsCoreAbstractMesh[];
    renderListPredicate?: (AbstractMesh: BabylonjsCoreAbstractMesh) => boolean;
    renderParticles?: boolean;
    renderSprites?: boolean;
    renderToTarget?: any;
    samples?: number;
    setRenderingAutoClearDepthStencil?: any;
    setRenderingOrder?: any;
    useCameraPostProcesses?: boolean;
} & FiberTextureProps;
export declare type FiberRenderTargetTexturePropsCtor = {
    name: string;
    size: number | {
        width: number;
        height: number;
        layers?: number;
    } | {
        ratio: number;
    };
    generateMipMaps?: boolean;
    doNotChangeAspectRatio?: boolean;
    type?: number;
    isCube?: boolean;
    samplingMode?: number;
    generateDepthBuffer?: boolean;
    generateStencilBuffer?: boolean;
    isMulti?: boolean;
    format?: number;
    delayAllocation?: boolean;
};
export declare type FiberMirrorTextureProps = {
    adaptiveBlurKernel?: number;
    blurKernel?: number;
    blurKernelX?: number;
    blurKernelY?: number;
    blurRatio?: number;
    mirrorPlane?: BabylonjsCorePlane;
    scene?: any;
} & FiberRenderTargetTextureProps;
export declare type FiberMirrorTexturePropsCtor = {
    name: string;
    size: number | {
        width: number;
        height: number;
    } | {
        ratio: number;
    };
    generateMipMaps?: boolean;
    type?: number;
    samplingMode?: number;
    generateDepthBuffer?: boolean;
};
export declare type FiberMultiRenderTargetProps = {
    samples?: number;
    wrapU?: number;
    wrapV?: number;
} & FiberRenderTargetTextureProps;
export declare type FiberMultiRenderTargetPropsCtor = {
    name: string;
    size: any;
    count: number;
    options?: BabylonjsCoreIMultiRenderTargetOptions;
};
export declare type FiberRefractionTextureProps = {
    depth?: number;
    refractionPlane?: BabylonjsCorePlane;
} & FiberRenderTargetTextureProps;
export declare type FiberRefractionTexturePropsCtor = {
    name: string;
    size: number;
    generateMipMaps?: boolean;
};
export declare type FiberMultiviewRenderTargetProps = {} & FiberRenderTargetTextureProps;
export declare type FiberMultiviewRenderTargetPropsCtor = {
    size?: number | {
        width: number;
        height: number;
    } | {
        ratio: number;
    };
};
export declare type FiberVideoTextureProps = {
    reset?: any;
} & FiberTextureProps;
export declare type FiberVideoTexturePropsCtor = {
    name: string;
    src: string | string[] | HTMLVideoElement;
    generateMipMaps?: boolean;
    invertY?: boolean;
    samplingMode?: number;
    settings?: BabylonjsCoreVideoTextureSettings;
};
export declare type FiberDynamicTextureProps = {} & FiberTextureProps;
export declare type FiberDynamicTexturePropsCtor = {
    name: string;
    options: any;
    generateMipMaps: boolean;
    samplingMode?: number;
    format?: number;
};
export declare type FiberAdvancedDynamicTextureProps = {
    addControl?: any;
    background?: string;
    clipboardData?: string;
    focusedControl?: BabylonjsGuiIFocusableControl;
    idealHeight?: number;
    idealWidth?: number;
    isForeground?: boolean;
    onBeginLayoutObservable?: any;
    onBeginRenderObservable?: any;
    onClipboardCopy?: any;
    onClipboardCut?: any;
    onClipboardObservable?: any;
    onClipboardPaste?: any;
    onControlPickedObservable?: any;
    onEndLayoutObservable?: any;
    onEndRenderObservable?: any;
    premulAlpha?: boolean;
    renderAtIdealSize?: boolean;
    renderScale?: number;
    useInvalidateRectOptimization?: boolean;
    useSmallestIdeal?: boolean;
} & FiberDynamicTextureProps;
export declare type FiberADTForMeshPropsCtor = {
    mesh: BabylonjsCoreAbstractMesh;
    width?: number;
    height?: number;
    supportPointerMove?: boolean;
    onlyAlphaTesting?: boolean;
};
export declare type FiberADTFullscreenUIPropsCtor = {
    name: string;
    foreground?: boolean;
    sampling?: number;
};
export declare type FiberAdvancedDynamicTexturePropsCtor = {
    name: string;
    width: number;
    height: number;
    generateMipMaps?: boolean;
    samplingMode?: number;
};
export declare type FiberRawTexture3DProps = {
    format?: number;
} & FiberTextureProps;
export declare type FiberRawTexture3DPropsCtor = {
    data: ArrayBufferView;
    width: number;
    height: number;
    depth: number;
    format: number;
    generateMipMaps?: boolean;
    invertY?: boolean;
    samplingMode?: number;
    textureType?: number;
};
export declare type FiberRawTexture2DArrayProps = {
    format?: number;
} & FiberTextureProps;
export declare type FiberRawTexture2DArrayPropsCtor = {
    data: ArrayBufferView;
    width: number;
    height: number;
    depth: number;
    format: number;
    generateMipMaps?: boolean;
    invertY?: boolean;
    samplingMode?: number;
    textureType?: number;
};
export declare type FiberColorGradingTextureProps = {
    load3dlTexture?: any;
    loadTexture?: any;
    url?: string;
} & FiberBaseTextureProps;
export declare type FiberColorGradingTexturePropsCtor = {
    url: string;
};
export declare type FiberEquiRectangularCubeTextureProps = {
    coordinatesMode?: number;
    getFloat32ArrayFromArrayBuffer?: any;
    loadImage?: any;
    loadTexture?: any;
    url?: string;
} & FiberBaseTextureProps;
export declare type FiberEquiRectangularCubeTexturePropsCtor = {
    url: string;
    size: number;
    noMipmap?: boolean;
    gammaSpace?: boolean;
    onLoad?: () => void;
    onError?: (message?: string, exception?: any) => void;
};
export declare type FiberHDRCubeTextureProps = {
    boundingBoxPosition?: BabylonjsCoreVector3;
    boundingBoxSize?: BabylonjsCoreVector3;
    coordinatesMode?: number;
    isBlocking?: boolean;
    loadTexture?: any;
    rotationY?: number;
    setReflectionTextureMatrix?: any;
    url?: string;
} & FiberBaseTextureProps;
export declare type FiberHDRCubeTexturePropsCtor = {
    url: string;
    size: number;
    noMipmap?: boolean;
    generateHarmonics?: boolean;
    gammaSpace?: boolean;
    reserved?: boolean;
    onLoad?: () => void;
    onError?: (message?: string, exception?: any) => void;
};
export declare type FiberHtmlElementTextureProps = {
    element?: HTMLVideoElement | HTMLCanvasElement;
} & FiberBaseTextureProps;
export declare type FiberHtmlElementTexturePropsCtor = {
    name: string;
    element: HTMLVideoElement | HTMLCanvasElement;
    options: BabylonjsCoreIHtmlElementTextureOptions;
};
export declare type FiberGUI3DManagerProps = {
    addControl?: any;
    onPickedPointChangedObservable?: any;
} & CustomProps;
export declare type FiberGUI3DManagerPropsCtor = {};
export declare type FiberShadowGeneratorProps = {
    addShadowCaster?: any;
    bias?: number;
    blurBoxOffset?: number;
    blurKernel?: number;
    blurScale?: number;
    contactHardeningLightSizeUVRatio?: number;
    customShaderOptions?: BabylonjsCoreICustomShaderOptions;
    darkness?: number;
    depthScale?: number;
    filter?: number;
    filteringQuality?: number;
    forceBackFacesOnly?: boolean;
    frustumEdgeFalloff?: number;
    normalBias?: number;
    onAfterShadowMapRenderMeshObservable?: any;
    onAfterShadowMapRenderObservable?: any;
    onBeforeShadowMapRenderMeshObservable?: any;
    onBeforeShadowMapRenderObservable?: any;
    setDarkness?: any;
    setTransparencyShadow?: any;
    transparencyShadow?: boolean;
    useBlurCloseExponentialShadowMap?: boolean;
    useBlurExponentialShadowMap?: boolean;
    useCloseExponentialShadowMap?: boolean;
    useContactHardeningShadow?: boolean;
    useExponentialShadowMap?: boolean;
    useKernelBlur?: boolean;
    usePercentageCloserFiltering?: boolean;
    usePoissonSampling?: boolean;
} & CustomProps;
export declare type FiberShadowGeneratorPropsCtor = {
    mapSize: number;
    light?: BabylonjsCoreIShadowLight;
    usefulFloatFirst?: boolean;
};
export declare type FiberEnvironmentHelperProps = {
    onErrorObservable?: any;
    setMainColor?: any;
} & CustomProps;
export declare type FiberEnvironmentHelperPropsCtor = {
    options: Partial<BabylonjsCoreIEnvironmentHelperOptions>;
};
export declare type FiberPhysicsImpostorProps = {
    addAnchor?: any;
    addHook?: any;
    addJoint?: any;
    afterStep?: () => void;
    beforeStep?: () => void;
    friction?: number;
    mass?: number;
    object?: BabylonjsCoreIPhysicsEnabledObject;
    onCollide?: (e: {
        body: any;
    }) => void;
    onCollideEvent?: (collider: BabylonjsCorePhysicsImpostor, collidedWith: BabylonjsCorePhysicsImpostor) => void;
    parent?: BabylonjsCorePhysicsImpostor;
    physicsBody?: any;
    positionIterations?: number;
    pressure?: number;
    restitution?: number;
    segments?: number;
    setAngularVelocity?: any;
    setDeltaPosition?: any;
    setDeltaRotation?: any;
    setLinearVelocity?: any;
    setMass?: any;
    setParam?: any;
    soft?: boolean;
    stiffness?: number;
    type?: number;
    uniqueId?: number;
    velocityIterations?: number;
} & CustomProps;
export declare type FiberPhysicsImpostorPropsCtor = {
    object?: BabylonjsCoreIPhysicsEnabledObject;
    type: number;
    _options?: BabylonjsCorePhysicsImpostorParameters;
};
export declare type FiberVRExperienceHelperProps = {
    addFloorMesh?: any;
    beforeRender?: any;
    completeVRInit?: any;
    displayGaze?: boolean;
    displayLaserPointer?: boolean;
    displayVRButton?: any;
    enableGazeEvenWhenNoPointerLock?: boolean;
    exitVROnDoubleTap?: boolean;
    gazeTrackerMesh?: BabylonjsCoreMesh;
    meshSelectionPredicate?: (mesh: BabylonjsCoreAbstractMesh) => boolean;
    moveButtonToBottomRight?: any;
    onAfterCameraTeleport?: any;
    onAfterEnteringVRObservable?: any;
    onBeforeCameraTeleport?: any;
    onControllerMeshLoadedObservable?: any;
    onEnteringVRObservable?: any;
    onExitingVRObservable?: any;
    onMeshSelectedWithController?: any;
    onNewMeshPicked?: any;
    onNewMeshSelected?: any;
    onSelectedMeshUnselected?: any;
    onVRDisplayChanged?: any;
    onVrDisplayPresentChange?: any;
    position?: BabylonjsCoreVector3;
    raySelectionPredicate?: (mesh: BabylonjsCoreAbstractMesh) => boolean;
    requestPointerLockOnFullScreen?: boolean;
    setGazeColor?: any;
    setLaserColor?: any;
    setLaserLightingState?: any;
    teleportationEnabled?: boolean;
    teleportationTarget?: BabylonjsCoreMesh;
    updateButtonVisibility?: any;
    updateControllerLaserColor?: boolean;
    updateGazeTrackerColor?: boolean;
    updateGazeTrackerScale?: boolean;
    webVROptions?: BabylonjsCoreVRExperienceHelperOptions;
    xr?: BabylonjsCoreWebXRDefaultExperience;
    xrTestDone?: boolean;
} & CustomProps;
export declare type FiberVRExperienceHelperPropsCtor = {
    webVROptions?: BabylonjsCoreVRExperienceHelperOptions;
};
export declare type FiberDynamicTerrainProps = {
    camera?: BabylonjsCoreCamera;
    cameraLODCorrection?: number;
    computeNormals?: boolean;
    initialLOD?: number;
    isAlwaysVisible?: boolean;
    LODLimits?: number[];
    LODNegativeX?: boolean;
    LODNegativeZ?: boolean;
    LODPositiveX?: boolean;
    LODPositiveZ?: boolean;
    mapColors?: BabylonjsCoreFloatArray;
    mapData?: BabylonjsCoreFloatArray;
    mapNormals?: BabylonjsCoreFloatArray;
    mapSubX?: number;
    mapSubZ?: number;
    mapUVs?: BabylonjsCoreFloatArray;
    name?: string;
    precomputeNormalsFromMap?: boolean;
    refreshEveryFrame?: boolean;
    shiftFromCamera?: {
        x: number;
        z: number;
    };
    subToleranceX?: number;
    subToleranceZ?: number;
    useCustomVertexFunction?: boolean;
} & CustomProps;
export declare type FiberDynamicTerrainPropsCtor = {
    name: string;
    terrainSub?: number;
    mapData?: BabylonjsCoreFloatArray;
    mapSubX?: number;
    mapSubZ?: number;
    mapUVs?: BabylonjsCoreFloatArray;
    mapColors?: BabylonjsCoreFloatArray;
    mapNormals?: BabylonjsCoreFloatArray;
    invertSide?: boolean;
    camera?: BabylonjsCoreCamera;
    SPmapData?: number[][] | Float32Array[];
    sps?: BabylonjsCoreSolidParticleSystem;
    SPcolorData?: number[][] | Float32Array[];
    SPuvData?: number[][] | Float32Array[];
    intializedCallback?: any;
};
export declare type FiberAutoRotationBehaviorProps = {
    idleRotationSpeed?: number;
    idleRotationSpinupTime?: number;
    idleRotationWaitTime?: number;
    zoomStopsAnimation?: boolean;
} & CustomProps;
export declare type FiberAutoRotationBehaviorPropsCtor = {};
export declare type FiberBouncingBehaviorProps = {
    autoTransitionRange?: boolean;
    lowerRadiusTransitionRange?: number;
    transitionDuration?: number;
    upperRadiusTransitionRange?: number;
} & CustomProps;
export declare type FiberBouncingBehaviorPropsCtor = {};
export declare type FiberFramingBehaviorProps = {
    autoCorrectCameraLimitsAndSensibility?: boolean;
    defaultElevation?: number;
    elevationReturnTime?: number;
    elevationReturnWaitTime?: number;
    framingTime?: number;
    mode?: number;
    positionScale?: number;
    radiusScale?: number;
    zoomStopsAnimation?: boolean;
} & CustomProps;
export declare type FiberFramingBehaviorPropsCtor = {};
export declare type FiberAttachToBoxBehaviorProps = {
    distanceAwayFromBottomOfFace?: number;
    distanceAwayFromFace?: number;
    name?: string;
    ui?: any;
} & CustomProps;
export declare type FiberAttachToBoxBehaviorPropsCtor = {
    ui: BabylonjsCoreTransformNode;
};
export declare type FiberFadeInOutBehaviorProps = {
    delay?: number;
    fadeInTime?: number;
} & CustomProps;
export declare type FiberFadeInOutBehaviorPropsCtor = {};
export declare type FiberMultiPointerScaleBehaviorProps = {} & CustomProps;
export declare type FiberMultiPointerScaleBehaviorPropsCtor = {};
export declare type FiberPointerDragBehaviorProps = {
    attachedNode?: BabylonjsCoreAbstractMesh;
    currentDraggingPointerID?: number;
    detachCameraControls?: boolean;
    dragDeltaRatio?: number;
    dragging?: boolean;
    enabled?: boolean;
    lastDragPosition?: BabylonjsCoreVector3;
    maxDragAngle?: number;
    moveAttached?: boolean;
    onDragEndObservable?: any;
    onDragObservable?: any;
    onDragStartObservable?: any;
    options?: {
        dragAxis?: BabylonjsCoreVector3;
        dragPlaneNormal?: BabylonjsCoreVector3;
    };
    startAndReleaseDragOnPointerEvents?: boolean;
    updateDragPlane?: boolean;
    useObjectOrientationForDragging?: boolean;
    validateDrag?: (targetPosition: BabylonjsCoreVector3) => boolean;
} & CustomProps;
export declare type FiberPointerDragBehaviorPropsCtor = {
    dragAxis?: BabylonjsCoreVector3;
    dragPlaneNormal?: BabylonjsCoreVector3;
};
export declare type FiberSixDofDragBehaviorProps = {
    currentDraggingPointerID?: number;
    detachCameraControls?: boolean;
    dragDeltaRatio?: number;
    dragging?: boolean;
    onDragEndObservable?: any;
    onDragStartObservable?: any;
    rotateDraggedObject?: boolean;
    zDragFactor?: any;
} & CustomProps;
export declare type FiberSixDofDragBehaviorPropsCtor = {};
export declare type FiberSceneProps = {
    actionManager?: BabylonjsCoreAbstractActionManager;
    activeCamera?: BabylonjsCoreCamera;
    activeCameras?: BabylonjsCoreCamera[];
    addActionManager?: any;
    addAnimation?: any;
    addAnimationGroup?: any;
    addCamera?: any;
    addExternalData?: any;
    addGeometry?: any;
    addLight?: any;
    addMaterial?: any;
    addMesh?: any;
    addMorphTargetManager?: any;
    addMultiMaterial?: any;
    addParticleSystem?: any;
    addSkeleton?: any;
    addTexture?: any;
    addTransformNode?: any;
    afterCameraRender?: () => void;
    afterRender?: () => void;
    ambientColor?: BabylonjsCoreColor3;
    animationPropertiesOverride?: BabylonjsCoreAnimationPropertiesOverride;
    animationsEnabled?: boolean;
    animationTimeScale?: number;
    autoClear?: boolean;
    autoClearDepthAndStencil?: boolean;
    beforeCameraRender?: () => void;
    beforeRender?: () => void;
    blockfreeActiveMeshesAndRenderingGroups?: boolean;
    blockMaterialDirtyMechanism?: boolean;
    cameraToUseForPointers?: BabylonjsCoreCamera;
    clearColor?: BabylonjsCoreColor4;
    clipPlane?: BabylonjsCorePlane;
    clipPlane2?: BabylonjsCorePlane;
    clipPlane3?: BabylonjsCorePlane;
    clipPlane4?: BabylonjsCorePlane;
    clipPlane5?: BabylonjsCorePlane;
    clipPlane6?: BabylonjsCorePlane;
    collisionsEnabled?: boolean;
    constantlyUpdateMeshUnderPointer?: boolean;
    customLODSelector?: (mesh: BabylonjsCoreAbstractMesh, camera: BabylonjsCoreCamera) => BabylonjsCoreAbstractMesh;
    customRenderTargets?: BabylonjsCoreRenderTargetTexture[];
    defaultCursor?: string;
    defaultMaterial?: BabylonjsCoreMaterial;
    deleteCompoundImpostor?: any;
    disableOfflineSupportExceptionRules?: RegExp[];
    dispatchAllSubMeshesOfActiveMeshes?: boolean;
    doNotHandleCursors?: boolean;
    DoubleClickDelay?: number;
    DragMovementThreshold?: number;
    dumpNextRenderTargets?: boolean;
    enablePhysics?: any;
    environmentBRDFTexture?: BabylonjsCoreBaseTexture;
    environmentIntensity?: number;
    environmentTexture?: BabylonjsCoreBaseTexture;
    ExclusiveDoubleClickMode?: boolean;
    fogColor?: BabylonjsCoreColor3;
    fogDensity?: number;
    fogEnabled?: boolean;
    fogEnd?: number;
    fogMode?: number;
    fogStart?: number;
    forcePointsCloud?: boolean;
    forceWireframe?: boolean;
    geometriesByUniqueId?: any;
    getActiveMeshCandidates?: () => BabylonjsCoreISmartArrayLike<BabylonjsCoreAbstractMesh>;
    getActiveSubMeshCandidates?: (mesh: BabylonjsCoreAbstractMesh) => BabylonjsCoreISmartArrayLike<BabylonjsCoreSubMesh>;
    getCollidingSubMeshCandidates?: (mesh: BabylonjsCoreAbstractMesh, collider: BabylonjsCoreCollider) => BabylonjsCoreISmartArrayLike<BabylonjsCoreSubMesh>;
    getDeterministicFrameTime?: () => number;
    getIntersectingSubMeshCandidates?: (mesh: BabylonjsCoreAbstractMesh, localRay: BabylonjsCoreRay) => BabylonjsCoreISmartArrayLike<BabylonjsCoreSubMesh>;
    gravity?: BabylonjsCoreVector3;
    hoverCursor?: string;
    importedMeshesFiles?: String[];
    lensFlaresEnabled?: boolean;
    lightsEnabled?: boolean;
    loadingPluginName?: string;
    LongPressDelay?: number;
    metadata?: any;
    offlineProvider?: BabylonjsCoreIOfflineProvider;
    onActiveCameraChanged?: any;
    onAfterActiveMeshesEvaluationObservable?: any;
    onAfterAnimationsObservable?: any;
    onAfterCameraRenderObservable?: any;
    onAfterDrawPhaseObservable?: any;
    onAfterParticlesRenderingObservable?: any;
    onAfterPhysicsObservable?: BabylonjsCoreObservable<BabylonjsCoreScene>;
    onAfterRenderCameraObservable?: any;
    onAfterRenderingGroupObservable?: any;
    onAfterRenderObservable?: any;
    onAfterRenderTargetsRenderObservable?: any;
    onAfterStepObservable?: any;
    onAnimationFileImportedObservable?: any;
    onBeforeActiveMeshesEvaluationObservable?: any;
    onBeforeAnimationsObservable?: any;
    onBeforeCameraRenderObservable?: any;
    onBeforeDrawPhaseObservable?: any;
    onBeforeParticlesRenderingObservable?: any;
    onBeforePhysicsObservable?: BabylonjsCoreObservable<BabylonjsCoreScene>;
    onBeforeRenderingGroupObservable?: any;
    onBeforeRenderObservable?: any;
    onBeforeRenderTargetsRenderObservable?: any;
    onBeforeStepObservable?: any;
    onCameraRemovedObservable?: any;
    onDataLoadedObservable?: any;
    onDispose?: () => void;
    onDisposeObservable?: any;
    onGeometryRemovedObservable?: any;
    onKeyboardObservable?: any;
    onLightRemovedObservable?: any;
    onMaterialRemovedObservable?: any;
    onMeshImportedObservable?: any;
    onMeshRemovedObservable?: any;
    onNewCameraAddedObservable?: any;
    onNewGeometryAddedObservable?: any;
    onNewLightAddedObservable?: any;
    onNewMaterialAddedObservable?: any;
    onNewMeshAddedObservable?: any;
    onNewSkeletonAddedObservable?: any;
    onNewTextureAddedObservable?: any;
    onNewTransformNodeAddedObservable?: any;
    onPointerDown?: (evt: PointerEvent, pickInfo: BabylonjsCorePickingInfo, type: BabylonjsCorePointerEventTypes) => void;
    onPointerMove?: (evt: PointerEvent, pickInfo: BabylonjsCorePickingInfo, type: BabylonjsCorePointerEventTypes) => void;
    onPointerObservable?: any;
    onPointerPick?: (evt: PointerEvent, pickInfo: BabylonjsCorePickingInfo) => void;
    onPointerUp?: (evt: PointerEvent, pickInfo: BabylonjsCorePickingInfo, type: BabylonjsCorePointerEventTypes) => void;
    onPreKeyboardObservable?: any;
    onPrePointerObservable?: any;
    onReadyObservable?: any;
    onSkeletonRemovedObservable?: any;
    onTextureRemovedObservable?: any;
    onTransformNodeRemovedObservable?: any;
    particlesEnabled?: boolean;
    pointerDownPredicate?: (Mesh: BabylonjsCoreAbstractMesh) => boolean;
    pointerMovePredicate?: (Mesh: BabylonjsCoreAbstractMesh) => boolean;
    pointerUpPredicate?: (Mesh: BabylonjsCoreAbstractMesh) => boolean;
    pointerX?: number;
    pointerY?: number;
    postProcesses?: BabylonjsCorePostProcess[];
    postProcessesEnabled?: boolean;
    postProcessManager?: BabylonjsCorePostProcessManager;
    preventDefaultOnPointerDown?: boolean;
    preventDefaultOnPointerUp?: boolean;
    probesEnabled?: boolean;
    proceduralTexturesEnabled?: boolean;
    renderTargetsEnabled?: boolean;
    requireLightSorting?: boolean;
    reservedDataStore?: any;
    setActiveCameraByID?: any;
    setActiveCameraByName?: any;
    setPointerOverMesh?: any;
    setRenderingAutoClearDepthStencil?: any;
    setRenderingOrder?: any;
    setStepId?: any;
    setTransformMatrix?: any;
    shadowsEnabled?: boolean;
    skeletonsEnabled?: boolean;
    skipFrustumClipping?: boolean;
    spritesEnabled?: boolean;
    texturesEnabled?: boolean;
    useConstantAnimationDeltaTime?: boolean;
    useDelayedTextureLoading?: boolean;
    useRightHandedSystem?: boolean;
} & CustomProps;