import { ARObjectModel, ARSessionOptions, ARFeatures, ARModelMaterial, ARLightConfiguration, ARShadowConfiguration, ARLightEstimation, ARLightEstimationMode } from './types';
/**
 * Manager for controlling AR sessions
 */
export declare class ARSessionManager {
    /**
     * Starts the AR session
     * @param options Optional configuration for the AR session
     */
    static startSession(options?: ARSessionOptions): Promise<void>;
    /**
     * Pauses the AR session
     */
    static pauseSession(): Promise<void>;
    /**
     * Resets the AR session
     */
    static resetSession(): Promise<void>;
    /**
     * Checks if AR is supported on the device
     */
    static isSupported(): Promise<boolean>;
    /**
     * Adds a 3D object to the scene with haptic feedback
     * @param model Model information
     */
    static addObject(model: ARObjectModel): Promise<string>;
    /**
     * Removes a 3D object from the scene with haptic feedback
     * @param id Object ID to remove
     */
    static removeObject(id: string): Promise<void>;
    /**
     * Moves an object to a new position with haptic feedback
     * @param id Object ID to move
     * @param position New position
     */
    static moveObject(id: string, position: {
        x: number;
        y: number;
        z: number;
    }): Promise<void>;
    /**
     * Rotates an object with haptic feedback
     * @param id Object ID to rotate
     * @param rotation New rotation in radians
     */
    static rotateObject(id: string, rotation: {
        x: number;
        y: number;
        z: number;
    }): Promise<void>;
    /**
     * Scales an object with haptic feedback
     * @param id Object ID to scale
     * @param scale New scale factor
     */
    static scaleObject(id: string, scale: number): Promise<void>;
    /**
     * Gets information about the object's current properties
     * @param id Object ID
     * @returns Current properties of the object
     */
    static getObjectProperties(id: string): Promise<{
        position: {
            x: number;
            y: number;
            z: number;
        };
        rotation: {
            x: number;
            y: number;
            z: number;
        };
        scale: number;
    }>;
    /**
     * Returns information about which AR features are supported on the current device
     * @returns Object containing feature support information
     */
    static getSupportedFeatures(): Promise<ARFeatures>;
    /**
     * Sets a property on the AR session
     * @param propertyName Name of the property to set
     * @param value Value to set
     */
    static setSessionProperty(propertyName: string, value: any): Promise<void>;
    /**
     * Gets the current value of a session property
     * @param propertyName Name of the property to get
     * @returns Current value of the property
     */
    static getSessionProperty(propertyName: string): Promise<any>;
    /**
     * For Android: Prompts the user to install ARCore if it's not already installed
     * @returns Promise that resolves to true if ARCore is installed or the user has agreed to install it
     */
    static promptARCoreInstall(): Promise<boolean>;
    /**
     * Loads a 3D model for use in the AR scene
     * This preloads the model to improve performance when it's actually placed in the scene
     * @param modelInfo Information about the 3D model to load
     * @returns Promise that resolves to a model ID that can be used for placement
     */
    static preloadModel(modelInfo: ARObjectModel): Promise<string>;
    /**
     * Checks if a model is loaded and ready for use
     * @param modelId ID of the model returned from preloadModel
     * @returns Promise that resolves to true if the model is loaded
     */
    static isModelLoaded(modelId: string): Promise<boolean>;
    /**
     * Unloads a preloaded model to free up memory
     * @param modelId ID of the model to unload
     * @returns Promise that resolves when the model is unloaded
     */
    static unloadModel(modelId: string): Promise<void>;
    /**
     * Places a preloaded model in the AR scene with haptic feedback
     * @param modelId ID of the preloaded model
     * @param position Position to place the model
     * @param options Additional options for placement (rotation, scale)
     * @returns Promise that resolves to the object ID of the placed model
     */
    static placeModel(modelId: string, position: {
        x: number;
        y: number;
        z: number;
    }, options?: {
        rotation?: {
            x: number;
            y: number;
            z: number;
        };
        scale?: number;
    }): Promise<string>;
    /**
     * Retrieves information about the available animations for a model
     * @param modelId ID of the model returned from preloadModel
     * @returns Promise that resolves to an array of animation names
     */
    static getModelAnimations(modelId: string): Promise<string[]>;
    /**
     * Plays an animation on a placed model
     * @param objectId ID of the placed object
     * @param animationName Name of the animation to play
     * @param options Optional animation parameters (loop, speed)
     * @returns Promise that resolves when the animation starts
     */
    static playAnimation(objectId: string, animationName: string, options?: {
        loop?: boolean;
        speed?: number;
    }): Promise<void>;
    /**
     * Stops all animations on a placed model
     * @param objectId ID of the placed object
     * @returns Promise that resolves when the animations are stopped
     */
    static stopAnimations(objectId: string): Promise<void>;
    /**
     * Updates the material properties of a placed model
     * @param objectId ID of the placed object
     * @param nodeName Name of the node/mesh to update (use '' for the entire model)
     * @param material Material properties to update
     * @returns Promise that resolves when the material is updated
     */
    static updateMaterial(objectId: string, nodeName: string, material: ARModelMaterial): Promise<void>;
    /**
     * Gets information about a 3D model, such as node names and materials
     * @param modelId ID of the preloaded model
     * @returns Promise that resolves to model information
     */
    static getModelInfo(modelId: string): Promise<{
        nodes: string[];
        materials: Record<string, ARModelMaterial>;
        boundingBox: {
            min: {
                x: number;
                y: number;
                z: number;
            };
            max: {
                x: number;
                y: number;
                z: number;
            };
        };
    }>;
    /**
     * Gets the current light estimation data from the AR session
     * @returns Promise that resolves to light estimation data
     */
    static getLightEstimation(): Promise<ARLightEstimation>;
    /**
     * Sets the light estimation mode for the AR session
     * @param mode Light estimation mode
     */
    static setLightEstimationMode(mode: ARLightEstimationMode): Promise<void>;
    /**
     * Adds a custom light to the AR scene
     * @param light Light configuration
     * @returns Promise that resolves to a unique ID for the light
     */
    static addLight(light: ARLightConfiguration): Promise<string>;
    /**
     * Updates an existing light's properties
     * @param lightId ID of the light to update
     * @param properties Updated light properties
     */
    static updateLight(lightId: string, properties: Partial<ARLightConfiguration>): Promise<void>;
    /**
     * Removes a custom light from the scene
     * @param lightId ID of the light to remove
     */
    static removeLight(lightId: string): Promise<void>;
    /**
     * Gets all custom lights in the scene
     * @returns Promise that resolves to an array of light IDs and their configurations
     */
    static getLights(): Promise<{
        id: string;
        config: ARLightConfiguration;
    }[]>;
    /**
     * Configures shadow rendering for the AR scene
     * @param configuration Shadow configuration
     */
    static configureShadows(configuration: ARShadowConfiguration): Promise<void>;
    /**
     * Gets the current shadow configuration
     * @returns Promise that resolves to the current shadow configuration
     */
    static getShadowConfiguration(): Promise<ARShadowConfiguration>;
    /**
     * Creates an environment probe at the specified position
     * Environment probes capture the surroundings for realistic reflections
     * @param position Position of the probe
     * @param size Size of the probe's capture area
     * @returns Promise that resolves to the probe ID
     */
    static createEnvironmentProbe(position: {
        x: number;
        y: number;
        z: number;
    }, size?: {
        width: number;
        height: number;
        depth: number;
    }): Promise<string>;
    /**
     * Updates an environment probe's position
     * @param probeId ID of the probe to update
     * @param position New position for the probe
     */
    static updateEnvironmentProbe(probeId: string, position: {
        x: number;
        y: number;
        z: number;
    }): Promise<void>;
    /**
     * Removes an environment probe
     * @param probeId ID of the probe to remove
     */
    static removeEnvironmentProbe(probeId: string): Promise<void>;
    /**
     * Sets whether objects should cast shadows
     * @param objectId ID of the object
     * @param castsShadow Whether the object should cast shadows
     */
    static setObjectCastsShadow(objectId: string, castsShadow: boolean): Promise<void>;
    /**
     * Sets whether objects should receive shadows
     * @param objectId ID of the object
     * @param receivesShadow Whether the object should receive shadows
     */
    static setObjectReceivesShadow(objectId: string, receivesShadow: boolean): Promise<void>;
    /**
     * Performs a hit test at the given position and returns information about what was hit
     * @param position Position to test
     * @returns Promise that resolves to hit test results
     */
    static performHitTest(position: {
        x: number;
        y: number;
        z: number;
    }): Promise<Array<{
        /**
         * Type of surface hit (horizontal, vertical, etc.)
         */
        type: string;
        /**
         * Distance from the camera to the hit point
         */
        distance: number;
        /**
         * Position of the hit point
         */
        position: {
            x: number;
            y: number;
            z: number;
        };
        /**
         * Normal vector of the hit surface
         */
        normal?: {
            x: number;
            y: number;
            z: number;
        };
        /**
         * Object ID that was hit (if any)
         */
        objectId?: string;
    }>>;
}
//# sourceMappingURL=ARSessionManager.d.ts.map