/** This file must only contain pure code and pure imports */
import { RenderTargetTexture } from "../Materials/Textures/renderTargetTexture.pure.js";
import { Vector3 } from "../Maths/math.vector.pure.js";
import { type AbstractMesh } from "../Meshes/abstractMesh.pure.js";
import { type Nullable } from "../types.js";
import { Scene } from "../scene.pure.js";
import { type IAssetContainer } from "../IAssetContainer.js";
/**
 * Class used to generate realtime reflection / refraction cube textures
 * @see https://doc.babylonjs.com/features/featuresDeepDive/environment/reflectionProbes
 */
export declare class ReflectionProbe {
    /** defines the name of the probe */
    name: string;
    private _scene;
    private _renderTargetTexture;
    private _projectionMatrix;
    private _viewMatrix;
    private _target;
    private _add;
    private _attachedMesh;
    private _invertYAxis;
    private _sceneUBOs;
    private _currentSceneUBO;
    /** Gets or sets probe position (center of the cube map) */
    position: Vector3;
    /**
     * Gets or sets an object used to store user defined information for the reflection probe.
     */
    metadata: any;
    /** @internal */
    _parentContainer: Nullable<IAssetContainer>;
    /**
     * Gets or sets if the probe should be serialized
     */
    doNotSerialize: boolean;
    /**
     * Creates a new reflection probe
     * @param name defines the name of the probe
     * @param size defines the texture resolution (for each face)
     * @param scene defines the hosting scene
     * @param generateMipMaps defines if mip maps should be generated automatically (true by default)
     * @param useFloat defines if HDR data (float data) should be used to store colors (false by default)
     * @param linearSpace defines if the probe should be generated in linear space or not (false by default)
     */
    constructor(
    /** defines the name of the probe */
    name: string, size: number, scene: Scene, generateMipMaps?: boolean, useFloat?: boolean, linearSpace?: boolean);
    /** Gets or sets the number of samples to use for multi-sampling (0 by default). Required WebGL2 */
    get samples(): number;
    set samples(value: number);
    /** Gets or sets the refresh rate to use (on every frame by default) */
    get refreshRate(): number;
    set refreshRate(value: number);
    /**
     * Gets the hosting scene
     * @returns a Scene
     */
    getScene(): Scene;
    /** Gets the internal CubeTexture used to render to */
    get cubeTexture(): RenderTargetTexture;
    /** Gets or sets the list of meshes to render */
    get renderList(): Nullable<AbstractMesh[]>;
    set renderList(value: Nullable<AbstractMesh[]>);
    /**
     * Attach the probe to a specific mesh (Rendering will be done from attached mesh's position)
     * @param mesh defines the mesh to attach to
     */
    attachToMesh(mesh: Nullable<AbstractMesh>): void;
    /**
     * Specifies whether or not the stencil and depth buffer are cleared between two rendering groups
     * @param renderingGroupId The rendering group id corresponding to its index
     * @param autoClearDepthStencil Automatically clears depth and stencil between groups if true.
     */
    setRenderingAutoClearDepthStencil(renderingGroupId: number, autoClearDepthStencil: boolean): void;
    /**
     * Clean all associated resources
     */
    dispose(): void;
    /**
     * Converts the reflection probe information to a readable string for debug purpose.
     * @param fullDetails Supports for multiple levels of logging within scene loading
     * @returns the human readable reflection probe info
     */
    toString(fullDetails?: boolean): string;
    /**
     * Get the class name of the refection probe.
     * @returns "ReflectionProbe"
     */
    getClassName(): string;
    /**
     * Serialize the reflection probe to a JSON representation we can easily use in the respective Parse function.
     * @returns The JSON representation of the texture
     */
    serialize(): any;
}
/**
 * Parse the JSON representation of a reflection probe in order to recreate the reflection probe in the given scene.
 * @param parsedReflectionProbe Define the JSON representation of the reflection probe
 * @param scene Define the scene the parsed reflection probe should be instantiated in
 * @param rootUrl Define the root url of the parsing sequence in the case of relative dependencies
 * @returns The parsed reflection probe if successful
 */
export declare function ReflectionProbeParse(parsedReflectionProbe: any, scene: Scene, rootUrl: string): Nullable<ReflectionProbe>;
/**
 * Register side effects for reflectionProbe.
 * Safe to call multiple times; only the first call has an effect.
 */
export declare function RegisterReflectionProbe(): void;
