react-babylonjs/dist/types/generatedCode.d.ts

React for Babylon.js

import { CreatedInstanceMetadata } from './CreatedInstance';
import { FiberAbstractButton3DProps, FiberAbstractMeshProps, FiberAdvancedDynamicTextureProps, FiberAnaglyphArcRotateCameraProps, FiberAnaglyphFreeCameraProps, FiberAnaglyphGamepadCameraProps, FiberAnaglyphPostProcessProps, FiberAnaglyphUniversalCameraProps, FiberArcFollowCameraProps, FiberArcRotateCameraProps, FiberAttachToBoxBehaviorProps, FiberAutoRotationBehaviorProps, FiberAxisDragGizmoProps, FiberAxisScaleGizmoProps, FiberBackgroundMaterialProps, FiberBaseSixDofDragBehaviorProps, FiberBaseSliderProps, FiberBaseTextureProps, FiberBlackAndWhitePostProcessProps, FiberBloomMergePostProcessProps, FiberBlurPostProcessProps, FiberBouncingBehaviorProps, FiberBoundingBoxGizmoProps, FiberButton3DProps, FiberButtonProps, FiberCameraGizmoProps, FiberCameraProps, FiberCascadedShadowGeneratorProps, FiberCheckboxProps, FiberChromaticAberrationPostProcessProps, FiberCircleOfConfusionPostProcessProps, FiberColorCorrectionPostProcessProps, FiberColorGradingTextureProps, FiberColorPickerProps, FiberContainer3DProps, FiberContainerProps, FiberContentDisplay3DProps, FiberControl3DProps, FiberControlProps, FiberConvolutionPostProcessProps, FiberCubeTextureProps, FiberCustomProceduralTextureProps, FiberCylinderPanelProps, FiberDefaultBehaviorProps, FiberDefaultRenderingPipelineProps, FiberDepthOfFieldBlurPostProcessProps, FiberDepthOfFieldMergePostProcessProps, FiberDetailMapConfigurationProps, FiberDeviceOrientationCameraProps, FiberDirectionalLightProps, FiberDisplayGridProps, FiberDisplayPassPostProcessProps, FiberDynamicTerrainProps, FiberDynamicTextureProps, FiberEffectLayerProps, FiberEllipseProps, FiberEngineViewProps, FiberEnvironmentHelperProps, FiberEquiRectangularCubeTextureProps, FiberExtractHighlightsPostProcessProps, FiberFadeInOutBehaviorProps, FiberFilterPostProcessProps, FiberFluentBackplateMaterialProps, FiberFluentButtonMaterialProps, FiberFluentMaterialProps, FiberFlyCameraProps, FiberFocusableButtonProps, FiberFollowBehaviorProps, FiberFollowCameraProps, FiberFramingBehaviorProps, FiberFreeCameraProps, FiberFxaaPostProcessProps, FiberGamepadCameraProps, FiberGaussianSplattingMaterialProps, FiberGaussianSplattingMeshProps, FiberGizmoManagerProps, FiberGizmoProps, FiberGlowLayerProps, FiberGoldbergMeshProps, FiberGrainPostProcessProps, FiberGreasedLineBaseMeshProps, FiberGreasedLineMeshProps, FiberGreasedLineRibbonMeshProps, FiberGreasedLineSimpleMaterialProps, FiberGridProps, FiberGroundMeshProps, FiberGUI3DManagerProps, FiberHandConstraintBehaviorProps, FiberHandleMaterialProps, FiberHandMenuProps, FiberHDRCubeTextureProps, FiberHemisphericLightProps, FiberHighlightLayerProps, FiberHighlightsPostProcessProps, FiberHolographicBackplateProps, FiberHolographicButtonProps, FiberHolographicSlateProps, FiberHtmlElementTextureProps, FiberIblShadowsRenderPipelineProps, FiberImageBasedSliderProps, FiberImageProcessingConfigurationProps, FiberImageProcessingPostProcessProps, FiberImageProps, FiberImageScrollBarProps, FiberInputPasswordProps, FiberInputTextAreaProps, FiberInputTextProps, FiberInstancedLinesMeshProps, FiberInstancedMeshProps, FiberLayerProps, FiberLensRenderingPipelineProps, FiberLightGizmoProps, FiberLightProps, FiberLineProps, FiberLinesMeshProps, FiberMaterialPluginBaseProps, FiberMaterialProps, FiberMeshButton3DProps, FiberMeshProps, FiberMirrorTextureProps, FiberMotionBlurPostProcessProps, FiberMRDLBackglowMaterialProps, FiberMRDLBackplateMaterialProps, FiberMRDLFrontplateMaterialProps, FiberMRDLInnerquadMaterialProps, FiberMRDLSliderBarMaterialProps, FiberMRDLSliderThumbMaterialProps, FiberMultiLineProps, FiberMultiMaterialProps, FiberMultiPointerScaleBehaviorProps, FiberMultiRenderTargetProps, FiberMultiviewRenderTargetProps, FiberNearMenuProps, FiberNodeMaterialProps, FiberNodeProps, FiberNoiseProceduralTextureProps, FiberOcclusionMaterialProps, FiberPassCubePostProcessProps, FiberPassPostProcessProps, FiberPBRAnisotropicConfigurationProps, FiberPBRBaseMaterialProps, FiberPBRBaseSimpleMaterialProps, FiberPBRBRDFConfigurationProps, FiberPBRClearCoatConfigurationProps, FiberPBRIridescenceConfigurationProps, FiberPBRMaterialProps, FiberPBRMetallicRoughnessMaterialProps, FiberPBRSheenConfigurationProps, FiberPBRSpecularGlossinessMaterialProps, FiberPBRSubSurfaceConfigurationProps, FiberPhysicsAggregateProps, FiberPhysicsImpostorProps, FiberPlaneDragGizmoProps, FiberPlanePanelProps, FiberPlaneRotationGizmoProps, FiberPointerDragBehaviorProps, FiberPointLightProps, FiberPointsCloudSystemProps, FiberPositionGizmoProps, FiberPostProcessProps, FiberPostProcessRenderPipelineProps, FiberPrePassConfigurationProps, FiberPrePassRenderTargetProps, FiberProceduralTextureProps, FiberPushMaterialProps, FiberRadioButtonProps, FiberRawCubeTextureProps, FiberRawTexture2DArrayProps, FiberRawTexture3DProps, FiberRawTextureProps, FiberRectangleProps, FiberRefractionPostProcessProps, FiberRefractionTextureProps, FiberRenderTargetTextureProps, FiberRotationGizmoProps, FiberScaleGizmoProps, FiberScatterPanelProps, FiberSceneProps, FiberScreenSpaceCurvaturePostProcessProps, FiberScreenSpaceReflectionPostProcessProps, FiberScrollBarProps, FiberScrollViewerProps, FiberSelectionPanelProps, FiberShaderMaterialProps, FiberShadowGeneratorProps, FiberShadowLightProps, FiberSharpenPostProcessProps, FiberSixDofDragBehaviorProps, FiberSlateGizmoProps, FiberSlider3DProps, FiberSliderProps, FiberSoundProps, FiberSpherePanelProps, FiberSpotLightProps, FiberSpriteManagerProps, FiberSpritePackedManagerProps, FiberSpriteProps, FiberSSAO2RenderingPipelineProps, FiberSSAORenderingPipelineProps, FiberSSRRenderingPipelineProps, FiberStackPanel3DProps, FiberStackPanelProps, FiberStandardMaterialProps, FiberStandardRenderingPipelineProps, FiberStereoscopicArcRotateCameraProps, FiberStereoscopicFreeCameraProps, FiberStereoscopicGamepadCameraProps, FiberStereoscopicInterlacePostProcessIProps, FiberStereoscopicInterlacePostProcessProps, FiberStereoscopicScreenUniversalCameraProps, FiberStereoscopicUniversalCameraProps, FiberSubSurfaceScatteringPostProcessProps, FiberSurfaceMagnetismBehaviorProps, FiberTAARenderingPipelineProps, FiberTargetCameraProps, FiberTextBlockProps, FiberTextureProps, FiberThinRenderTargetTextureProps, FiberThinSpriteProps, FiberThinTextureProps, FiberToggleButtonProps, FiberTonemapPostProcessProps, FiberTouchButton3DProps, FiberTouchCameraProps, FiberTouchHolographicButtonProps, FiberTouchHolographicMenuProps, FiberTouchMeshButton3DProps, FiberTrailMeshProps, FiberTransformNodeProps, FiberUniversalCameraProps, FiberUtilityLayerRendererProps, FiberVideoTextureProps, FiberViewportProps, FiberVirtualJoysticksCameraProps, FiberVirtualKeyboardProps, FiberVolumeBasedPanelProps, FiberVolumetricLightScatteringPostProcessProps, FiberVRDeviceOrientationArcRotateCameraProps, FiberVRDeviceOrientationFreeCameraProps, FiberVRDeviceOrientationGamepadCameraProps, FiberVRDistortionCorrectionPostProcessProps, FiberVRExperienceHelperProps, FiberVRMultiviewToSingleviewPostProcessProps, FiberWebXRCameraProps, FiberXRSpaceWarpRenderTargetProps, Fiber_ScrollViewerWindowProps } from './generatedProps';
import { HasPropsHandlers, PropertyUpdate, PropsHandler } from './PropsHandler';
export declare class FiberNodePropsHandler implements PropsHandler<FiberNodeProps> {
    getPropertyUpdates(oldProps: FiberNodeProps, newProps: FiberNodeProps): PropertyUpdate[] | null;
}
/**
 * Node is the basic class for all scene objects (Mesh, Light, Camera.)
 *
 * This code has been generated
 */
export declare class FiberNode implements HasPropsHandlers<FiberNodeProps> {
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberNodeProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberNodeProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberTransformNodePropsHandler implements PropsHandler<FiberTransformNodeProps> {
    getPropertyUpdates(oldProps: FiberTransformNodeProps, newProps: FiberTransformNodeProps): PropertyUpdate[] | null;
}
/**
 * A TransformNode is an object that is not rendered but can be used as a center of transformation. This can decrease memory usage and increase rendering speed compared to using an empty mesh as a parent and is less complicated than using a pivot matrix.
 *
 * This code has been generated
 */
export declare class FiberTransformNode implements HasPropsHandlers<FiberNodeProps> {
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberNodeProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberNodeProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberAbstractMeshPropsHandler implements PropsHandler<FiberAbstractMeshProps> {
    getPropertyUpdates(oldProps: FiberAbstractMeshProps, newProps: FiberAbstractMeshProps): PropertyUpdate[] | null;
}
/**
 * Class used to store all common mesh properties
 *
 * This code has been generated
 */
export declare class FiberAbstractMesh implements HasPropsHandlers<FiberAbstractMeshProps> {
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberAbstractMeshProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberAbstractMeshProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberInstancedMeshPropsHandler implements PropsHandler<FiberInstancedMeshProps> {
    getPropertyUpdates(oldProps: FiberInstancedMeshProps, newProps: FiberInstancedMeshProps): PropertyUpdate[] | null;
}
/**
 * Creates an instance based on a source mesh.
 *
 * This code has been generated
 */
export declare class FiberInstancedMesh implements HasPropsHandlers<FiberAbstractMeshProps> {
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberAbstractMeshProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberAbstractMeshProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberInstancedLinesMeshPropsHandler implements PropsHandler<FiberInstancedLinesMeshProps> {
    getPropertyUpdates(oldProps: FiberInstancedLinesMeshProps, newProps: FiberInstancedLinesMeshProps): PropertyUpdate[] | null;
}
/**
 * Creates an instance based on a source LinesMesh
 *
 * This code has been generated
 */
export declare class FiberInstancedLinesMesh implements HasPropsHandlers<FiberAbstractMeshProps> {
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberAbstractMeshProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberAbstractMeshProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberMeshPropsHandler implements PropsHandler<FiberMeshProps> {
    getPropertyUpdates(oldProps: FiberMeshProps, newProps: FiberMeshProps): PropertyUpdate[] | null;
}
/**
 * Class used to represent renderable models
 *
 * This code has been generated
 */
export declare class FiberMesh implements HasPropsHandlers<FiberAbstractMeshProps> {
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberAbstractMeshProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberAbstractMeshProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberGoldbergMeshPropsHandler implements PropsHandler<FiberGoldbergMeshProps> {
    getPropertyUpdates(oldProps: FiberGoldbergMeshProps, newProps: FiberGoldbergMeshProps): PropertyUpdate[] | null;
}
/**
 * Mesh for a Goldberg Polyhedron which is made from 12 pentagonal and the rest hexagonal faces
 *
 * This code has been generated
 */
export declare class FiberGoldbergMesh implements HasPropsHandlers<FiberAbstractMeshProps> {
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberAbstractMeshProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberAbstractMeshProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: never[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberGroundMeshPropsHandler implements PropsHandler<FiberGroundMeshProps> {
    getPropertyUpdates(oldProps: FiberGroundMeshProps, newProps: FiberGroundMeshProps): PropertyUpdate[] | null;
}
/**
 * Mesh representing the ground
 *
 * This code has been generated
 */
export declare class FiberGroundMesh implements HasPropsHandlers<FiberAbstractMeshProps> {
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberAbstractMeshProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberAbstractMeshProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberLinesMeshPropsHandler implements PropsHandler<FiberLinesMeshProps> {
    getPropertyUpdates(oldProps: FiberLinesMeshProps, newProps: FiberLinesMeshProps): PropertyUpdate[] | null;
}
/**
 * Line mesh
 *
 * This code has been generated
 */
export declare class FiberLinesMesh implements HasPropsHandlers<FiberAbstractMeshProps> {
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberAbstractMeshProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberAbstractMeshProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberTrailMeshPropsHandler implements PropsHandler<FiberTrailMeshProps> {
    getPropertyUpdates(oldProps: FiberTrailMeshProps, newProps: FiberTrailMeshProps): PropertyUpdate[] | null;
}
/**
 * Class used to create a trail following a mesh
 *
 * This code has been generated
 */
export declare class FiberTrailMesh implements HasPropsHandlers<FiberAbstractMeshProps> {
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberAbstractMeshProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberAbstractMeshProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberGreasedLineBaseMeshPropsHandler implements PropsHandler<FiberGreasedLineBaseMeshProps> {
    getPropertyUpdates(oldProps: FiberGreasedLineBaseMeshProps, newProps: FiberGreasedLineBaseMeshProps): PropertyUpdate[] | null;
}
/**
 * GreasedLineBaseMesh
 *
 * This code has been generated
 */
export declare class FiberGreasedLineBaseMesh implements HasPropsHandlers<FiberAbstractMeshProps> {
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberAbstractMeshProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberAbstractMeshProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberGreasedLineMeshPropsHandler implements PropsHandler<FiberGreasedLineMeshProps> {
    getPropertyUpdates(oldProps: FiberGreasedLineMeshProps, newProps: FiberGreasedLineMeshProps): PropertyUpdate[] | null;
}
/**
 * GreasedLineMesh
 * Use the GreasedLineBuilder.CreateGreasedLine function to create an instance of this class.
 *
 * This code has been generated
 */
export declare class FiberGreasedLineMesh implements HasPropsHandlers<FiberAbstractMeshProps> {
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberAbstractMeshProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberAbstractMeshProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberGreasedLineRibbonMeshPropsHandler implements PropsHandler<FiberGreasedLineRibbonMeshProps> {
    getPropertyUpdates(oldProps: FiberGreasedLineRibbonMeshProps, newProps: FiberGreasedLineRibbonMeshProps): PropertyUpdate[] | null;
}
/**
 * GreasedLineRibbonMesh
 * Use the GreasedLineBuilder.CreateGreasedLine function to create an instance of this class.
 *
 * This code has been generated
 */
export declare class FiberGreasedLineRibbonMesh implements HasPropsHandlers<FiberAbstractMeshProps> {
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberAbstractMeshProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberAbstractMeshProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberGaussianSplattingMeshPropsHandler implements PropsHandler<FiberGaussianSplattingMeshProps> {
    getPropertyUpdates(oldProps: FiberGaussianSplattingMeshProps, newProps: FiberGaussianSplattingMeshProps): PropertyUpdate[] | null;
}
/**
 * Class used to render a gaussian splatting mesh
 *
 * This code has been generated
 */
export declare class FiberGaussianSplattingMesh implements HasPropsHandlers<FiberAbstractMeshProps> {
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberAbstractMeshProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberAbstractMeshProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberCameraPropsHandler implements PropsHandler<FiberCameraProps> {
    getPropertyUpdates(oldProps: FiberCameraProps, newProps: FiberCameraProps): PropertyUpdate[] | null;
}
/**
 * This is the base class of all the camera used in the application.
 *
 * This code has been generated
 */
export declare class FiberCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = false;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberTargetCameraPropsHandler implements PropsHandler<FiberTargetCameraProps> {
    getPropertyUpdates(oldProps: FiberTargetCameraProps, newProps: FiberTargetCameraProps): PropertyUpdate[] | null;
}
/**
 * A target camera takes a mesh or position as a target and continues to look at it while it moves.
 * This is the base of the follow, arc rotate cameras and Free camera
 *
 * This code has been generated
 */
export declare class FiberTargetCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberFreeCameraPropsHandler implements PropsHandler<FiberFreeCameraProps> {
    getPropertyUpdates(oldProps: FiberFreeCameraProps, newProps: FiberFreeCameraProps): PropertyUpdate[] | null;
}
/**
 * This represents a free type of camera. It can be useful in First Person Shooter game for instance.
 * Please consider using the new UniversalCamera instead as it adds more functionality like the gamepad.
 *
 * This code has been generated
 */
export declare class FiberFreeCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberWebXRCameraPropsHandler implements PropsHandler<FiberWebXRCameraProps> {
    getPropertyUpdates(oldProps: FiberWebXRCameraProps, newProps: FiberWebXRCameraProps): PropertyUpdate[] | null;
}
/**
 * WebXR Camera which holds the views for the xrSession
 *
 * This code has been generated
 */
export declare class FiberWebXRCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberTouchCameraPropsHandler implements PropsHandler<FiberTouchCameraProps> {
    getPropertyUpdates(oldProps: FiberTouchCameraProps, newProps: FiberTouchCameraProps): PropertyUpdate[] | null;
}
/**
 * This represents a FPS type of camera controlled by touch.
 * This is like a universal camera minus the Gamepad controls.
 *
 * This code has been generated
 */
export declare class FiberTouchCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberUniversalCameraPropsHandler implements PropsHandler<FiberUniversalCameraProps> {
    getPropertyUpdates(oldProps: FiberUniversalCameraProps, newProps: FiberUniversalCameraProps): PropertyUpdate[] | null;
}
/**
 * The Universal Camera is the one to choose for first person shooter type games, and works with all the keyboard, mouse, touch and gamepads. This replaces the earlier Free Camera,
 * which still works and will still be found in many Playgrounds.
 *
 * This code has been generated
 */
export declare class FiberUniversalCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberGamepadCameraPropsHandler implements PropsHandler<FiberGamepadCameraProps> {
    getPropertyUpdates(oldProps: FiberGamepadCameraProps, newProps: FiberGamepadCameraProps): PropertyUpdate[] | null;
}
/**
 * This represents a FPS type of camera. This is only here for back compat purpose.
 * Please use the UniversalCamera instead as both are identical.
 *
 * This code has been generated
 */
export declare class FiberGamepadCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberAnaglyphGamepadCameraPropsHandler implements PropsHandler<FiberAnaglyphGamepadCameraProps> {
    getPropertyUpdates(oldProps: FiberAnaglyphGamepadCameraProps, newProps: FiberAnaglyphGamepadCameraProps): PropertyUpdate[] | null;
}
/**
 * Camera used to simulate anaglyphic rendering (based on GamepadCamera)
 *
 * This code has been generated
 */
export declare class FiberAnaglyphGamepadCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberStereoscopicGamepadCameraPropsHandler implements PropsHandler<FiberStereoscopicGamepadCameraProps> {
    getPropertyUpdates(oldProps: FiberStereoscopicGamepadCameraProps, newProps: FiberStereoscopicGamepadCameraProps): PropertyUpdate[] | null;
}
/**
 * Camera used to simulate stereoscopic rendering (based on GamepadCamera)
 *
 * This code has been generated
 */
export declare class FiberStereoscopicGamepadCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberAnaglyphUniversalCameraPropsHandler implements PropsHandler<FiberAnaglyphUniversalCameraProps> {
    getPropertyUpdates(oldProps: FiberAnaglyphUniversalCameraProps, newProps: FiberAnaglyphUniversalCameraProps): PropertyUpdate[] | null;
}
/**
 * Camera used to simulate anaglyphic rendering (based on UniversalCamera)
 *
 * This code has been generated
 */
export declare class FiberAnaglyphUniversalCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberStereoscopicUniversalCameraPropsHandler implements PropsHandler<FiberStereoscopicUniversalCameraProps> {
    getPropertyUpdates(oldProps: FiberStereoscopicUniversalCameraProps, newProps: FiberStereoscopicUniversalCameraProps): PropertyUpdate[] | null;
}
/**
 * Camera used to simulate stereoscopic rendering (based on UniversalCamera)
 *
 * This code has been generated
 */
export declare class FiberStereoscopicUniversalCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberStereoscopicScreenUniversalCameraPropsHandler implements PropsHandler<FiberStereoscopicScreenUniversalCameraProps> {
    getPropertyUpdates(oldProps: FiberStereoscopicScreenUniversalCameraProps, newProps: FiberStereoscopicScreenUniversalCameraProps): PropertyUpdate[] | null;
}
/**
 * Camera used to simulate stereoscopic rendering on real screens (based on UniversalCamera)
 *
 * This code has been generated
 */
export declare class FiberStereoscopicScreenUniversalCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberDeviceOrientationCameraPropsHandler implements PropsHandler<FiberDeviceOrientationCameraProps> {
    getPropertyUpdates(oldProps: FiberDeviceOrientationCameraProps, newProps: FiberDeviceOrientationCameraProps): PropertyUpdate[] | null;
}
/**
 * This is a camera specifically designed to react to device orientation events such as a modern mobile device
 * being tilted forward or back and left or right.
 *
 * This code has been generated
 */
export declare class FiberDeviceOrientationCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberVRDeviceOrientationFreeCameraPropsHandler implements PropsHandler<FiberVRDeviceOrientationFreeCameraProps> {
    getPropertyUpdates(oldProps: FiberVRDeviceOrientationFreeCameraProps, newProps: FiberVRDeviceOrientationFreeCameraProps): PropertyUpdate[] | null;
}
/**
 * Camera used to simulate VR rendering (based on FreeCamera)
 *
 * This code has been generated
 */
export declare class FiberVRDeviceOrientationFreeCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberVRDeviceOrientationGamepadCameraPropsHandler implements PropsHandler<FiberVRDeviceOrientationGamepadCameraProps> {
    getPropertyUpdates(oldProps: FiberVRDeviceOrientationGamepadCameraProps, newProps: FiberVRDeviceOrientationGamepadCameraProps): PropertyUpdate[] | null;
}
/**
 * Camera used to simulate VR rendering (based on VRDeviceOrientationFreeCamera)
 *
 * This code has been generated
 */
export declare class FiberVRDeviceOrientationGamepadCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberAnaglyphFreeCameraPropsHandler implements PropsHandler<FiberAnaglyphFreeCameraProps> {
    getPropertyUpdates(oldProps: FiberAnaglyphFreeCameraProps, newProps: FiberAnaglyphFreeCameraProps): PropertyUpdate[] | null;
}
/**
 * Camera used to simulate anaglyphic rendering (based on FreeCamera)
 *
 * This code has been generated
 */
export declare class FiberAnaglyphFreeCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberStereoscopicFreeCameraPropsHandler implements PropsHandler<FiberStereoscopicFreeCameraProps> {
    getPropertyUpdates(oldProps: FiberStereoscopicFreeCameraProps, newProps: FiberStereoscopicFreeCameraProps): PropertyUpdate[] | null;
}
/**
 * Camera used to simulate stereoscopic rendering (based on FreeCamera)
 *
 * This code has been generated
 */
export declare class FiberStereoscopicFreeCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberVirtualJoysticksCameraPropsHandler implements PropsHandler<FiberVirtualJoysticksCameraProps> {
    getPropertyUpdates(oldProps: FiberVirtualJoysticksCameraProps, newProps: FiberVirtualJoysticksCameraProps): PropertyUpdate[] | null;
}
/**
 * This represents a free type of camera. It can be useful in First Person Shooter game for instance.
 * It is identical to the Free Camera and simply adds by default a virtual joystick.
 * Virtual Joysticks are on-screen 2D graphics that are used to control the camera or other scene items.
 *
 * This code has been generated
 */
export declare class FiberVirtualJoysticksCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberArcRotateCameraPropsHandler implements PropsHandler<FiberArcRotateCameraProps> {
    getPropertyUpdates(oldProps: FiberArcRotateCameraProps, newProps: FiberArcRotateCameraProps): PropertyUpdate[] | null;
}
/**
 * This represents an orbital type of camera.
 *
 * This camera always points towards a given target position and can be rotated around that target with the target as the centre of rotation. It can be controlled with cursors and mouse, or with touch events.
 * Think of this camera as one orbiting its target position, or more imaginatively as a spy satellite orbiting the earth. Its position relative to the target (earth) can be set by three parameters, alpha (radians) the longitudinal rotation, beta (radians) the latitudinal rotation and radius the distance from the target position.
 *
 * This code has been generated
 */
export declare class FiberArcRotateCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberAnaglyphArcRotateCameraPropsHandler implements PropsHandler<FiberAnaglyphArcRotateCameraProps> {
    getPropertyUpdates(oldProps: FiberAnaglyphArcRotateCameraProps, newProps: FiberAnaglyphArcRotateCameraProps): PropertyUpdate[] | null;
}
/**
 * Camera used to simulate anaglyphic rendering (based on ArcRotateCamera)
 *
 * This code has been generated
 */
export declare class FiberAnaglyphArcRotateCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberStereoscopicArcRotateCameraPropsHandler implements PropsHandler<FiberStereoscopicArcRotateCameraProps> {
    getPropertyUpdates(oldProps: FiberStereoscopicArcRotateCameraProps, newProps: FiberStereoscopicArcRotateCameraProps): PropertyUpdate[] | null;
}
/**
 * Camera used to simulate stereoscopic rendering (based on ArcRotateCamera)
 *
 * This code has been generated
 */
export declare class FiberStereoscopicArcRotateCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberVRDeviceOrientationArcRotateCameraPropsHandler implements PropsHandler<FiberVRDeviceOrientationArcRotateCameraProps> {
    getPropertyUpdates(oldProps: FiberVRDeviceOrientationArcRotateCameraProps, newProps: FiberVRDeviceOrientationArcRotateCameraProps): PropertyUpdate[] | null;
}
/**
 * Camera used to simulate VR rendering (based on ArcRotateCamera)
 *
 * This code has been generated
 */
export declare class FiberVRDeviceOrientationArcRotateCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberFlyCameraPropsHandler implements PropsHandler<FiberFlyCameraProps> {
    getPropertyUpdates(oldProps: FiberFlyCameraProps, newProps: FiberFlyCameraProps): PropertyUpdate[] | null;
}
/**
 * This is a flying camera, designed for 3D movement and rotation in all directions,
 * such as in a 3D Space Shooter or a Flight Simulator.
 *
 * This code has been generated
 */
export declare class FiberFlyCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberFollowCameraPropsHandler implements PropsHandler<FiberFollowCameraProps> {
    getPropertyUpdates(oldProps: FiberFollowCameraProps, newProps: FiberFollowCameraProps): PropertyUpdate[] | null;
}
/**
 * A follow camera takes a mesh as a target and follows it as it moves. Both a free camera version followCamera and
 * an arc rotate version arcFollowCamera are available.
 *
 * This code has been generated
 */
export declare class FiberFollowCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
export declare class FiberArcFollowCameraPropsHandler implements PropsHandler<FiberArcFollowCameraProps> {
    getPropertyUpdates(oldProps: FiberArcFollowCameraProps, newProps: FiberArcFollowCameraProps): PropertyUpdate[] | null;
}
/**
 * Arc Rotate version of the follow camera.
 * It still follows a Defined mesh but in an Arc Rotate Camera fashion.
 *
 * This code has been generated
 */
export declare class FiberArcFollowCamera implements HasPropsHandlers<FiberCameraProps> {
    readonly isTargetable = true;
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberCameraProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberCameraProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        parameters: {
            name: string;
            type: string;
            optional: boolean;
        }[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
/**
 * Creates a box mesh
 * * The parameter `size` sets the size (float) of each box side (default 1)
 * * You can set some different box dimensions by using the parameters `width`, `height` and `depth` (all by default have the same value of `size`)
 * * You can set different colors and different images to each box side by using the parameters `faceColors` (an array of 6 Color3 elements) and `faceUV` (an array of 6 Vector4 elements)
 * * Please read this tutorial : https://doc.babylonjs.com/features/featuresDeepDive/materials/using/texturePerBoxFace
 * * You can also set the mesh side orientation with the values : BABYLON.Mesh.FRONTSIDE (default), BABYLON.Mesh.BACKSIDE or BABYLON.Mesh.DOUBLESIDE
 * * If you create a double-sided mesh, you can choose what parts of the texture image to crop and stick respectively on the front and the back sides with the parameters `frontUVs` and `backUVs` (Vector4). Detail here : https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation
 * * The mesh can be set to updatable with the boolean parameter `updatable` (default false) if its internal geometry is supposed to change once created
 *
 * This code has been generated
 */
export declare class FiberBox implements HasPropsHandlers<FiberMeshProps> {
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberMeshProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberMeshProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        factoryMethod: string;
        parameters: ({
            name: string;
            type: string;
            optional: boolean;
        } | {
            name: string;
            type: {
                name: string;
                type: string;
                optional: boolean;
            }[];
            optional: boolean;
        })[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
/**
 * Creates a tiled box mesh
 *
 * This code has been generated
 */
export declare class FiberTiledBox implements HasPropsHandlers<FiberMeshProps> {
    private propsHandlers;
    constructor();
    getPropsHandlers(): PropsHandler<FiberMeshProps>[];
    addPropsHandler(propHandler: PropsHandler<FiberMeshProps>): void;
    static readonly CreateInfo: {
        creationType: string;
        libraryLocation: string;
        namespace: string;
        factoryMethod: string;
        parameters: ({
            name: string;
            type: string;
            optional: boolean;
        } | {
            name: string;
            type: {
                name: string;
                type: string;
                optional: boolean;
            }[];
            optional: boolean;
        })[];
    };
    static readonly Metadata: CreatedInstanceMetadata;
}
/**
 * Creates a sphere mesh
 * * The parameter `diameter` sets the diameter size (float) of the sphere (default 1)
 * * You can set some different sphere dimensions, for instance to build an ellipsoid, by using the parameters `diameterX`, `diameterY` and `diameterZ` (all by default have the same value of `diameter`)
 * * The parameter `segments` sets the sphere number of horizontal stripes (positive integer, default 32)
 * * You can create an unclosed sphere with the parameter `arc` (positive float, default 1), valued between 0 and 1, what is the ratio of the circumference (latitude) : 2 x PI x ratio
 * * You can create an unclosed sphere on its height with the parameter `slice` (positive float, default1), valued between 0 and 1, what is the height ratio (longitude)
 * * You can also set the mesh side orientation with the values : BABYLON.Mesh.FRONTSIDE (default), BABYLON.Mesh.BACKSIDE or BABYLON.Mesh.DOUBLESIDE
 * * If you create a double-sided mesh, you can choose what parts of the texture image to crop and stick respectively on the front and the back side