import { OrbitCamera, OrbitCameraOptions } from './camera/OrbitCamera';
import { OrbitController, OrbitControllerOptions } from './controls/OrbitController';
import { Axes3DOptions } from './Axes3D';
import { Ray3D, HitResult } from './Raycaster3D';
import { Bubble3DData, Bubble3DStyle, Renderer3DOptions, RenderStats3D, Renderer3DEventCallback } from './types';
import { Tooltip3DOptions, Tooltip3DData } from './Tooltip3D';
import { CustomThemeOptions } from './colorThemes';

export interface Bubble3DRendererOptions extends Renderer3DOptions {
    camera?: OrbitCameraOptions;
    controls?: OrbitControllerOptions;
    style?: Bubble3DStyle;
    autoRender?: boolean;
    /** Axes configuration */
    axes?: Axes3DOptions;
    /** Show axes (default: true) */
    showAxes?: boolean;
    /** Enable tooltips on hover (default: true) */
    enableTooltip?: boolean;
    /** Tooltip configuration */
    tooltip?: Tooltip3DOptions;
    /** Custom tooltip formatter */
    tooltipFormatter?: (data: Tooltip3DData) => string;
    /** Color theme options */
    theme?: CustomThemeOptions;
}
export declare class Bubble3DRenderer {
    private canvas;
    private gl;
    private dpr;
    private programs;
    private mesh;
    private camera;
    private controller;
    private axes;
    private backgroundColor;
    private style;
    private showAxes;
    private instanceData;
    private bounds;
    private animationFrameId;
    private autoRender;
    private needsRender;
    private eventListeners;
    private tooltip;
    private enableTooltip;
    private lastHitIndex;
    private boundHandleMouseMove;
    private boundHandleMouseLeave;
    private lastFrameTime;
    private frameCount;
    private fps;
    private lastFpsUpdate;
    private colorTheme;
    constructor(options: Bubble3DRendererOptions);
    private handleMouseMove;
    private handleMouseLeave;
    private createGeometry;
    private handleResize;
    /**
     * Resize canvas to match display size.
     */
    resize(): void;
    /**
     * Set bubble data for rendering.
     */
    setData(data: Bubble3DData): void;
    private calculateBounds;
    /**
     * Fit camera to view all data.
     */
    fitToData(): void;
    /**
     * Render a single frame.
     */
    render(): void;
    /**
     * Start automatic render loop.
     */
    startRenderLoop(): void;
    /**
     * Stop automatic render loop.
     */
    stopRenderLoop(): void;
    /**
     * Request a render on next frame.
     */
    requestRender(): void;
    /**
     * Get render statistics.
     */
    getStats(): RenderStats3D;
    /**
     * Get camera instance for direct manipulation.
     */
    getCamera(): OrbitCamera;
    /**
     * Get controller instance for configuration.
     */
    getController(): OrbitController;
    /**
     * Update style options.
     */
    setStyle(style: Partial<Bubble3DStyle>): void;
    /**
     * Set background color.
     */
    setBackgroundColor(r: number, g: number, b: number, a?: number): void;
    /**
     * Add event listener.
     */
    on(event: string, callback: Renderer3DEventCallback): void;
    /**
     * Remove event listener.
     */
    off(event: string, callback: Renderer3DEventCallback): void;
    private emitEvent;
    /**
     * Get axis labels for 2D text overlay rendering.
     * Returns labels with world positions that need to be projected to screen.
     */
    getAxisLabels(): {
        text: string;
        worldPosition: [number, number, number];
        axis: string;
        color: [number, number, number];
    }[];
    /**
     * Project world coordinates to screen coordinates.
     * Useful for positioning 2D overlay text.
     */
    projectToScreen(worldPos: [number, number, number]): {
        x: number;
        y: number;
        visible: boolean;
    };
    /**
     * Get the current view-projection matrix.
     */
    getViewProjectionMatrix(): Float32Array;
    /**
     * Get canvas dimensions.
     */
    getCanvasSize(): {
        width: number;
        height: number;
    };
    /**
     * Get WebGL context info.
     */
    getContextInfo(): Record<string, any>;
    /**
     * Pick a bubble at screen coordinates.
     * @param screenX X coordinate relative to canvas
     * @param screenY Y coordinate relative to canvas
     * @returns Hit result with bubble index, or null if no hit
     */
    pickAtScreen(screenX: number, screenY: number): HitResult | null;
    /**
     * Create a ray from screen coordinates.
     * Useful for custom picking logic.
     */
    createRay(screenX: number, screenY: number): Ray3D;
    /**
     * Get data for a specific bubble by index.
     */
    getBubbleData(index: number): {
        position: [number, number, number];
        color: [number, number, number];
        scale: number;
    } | null;
    /**
     * Export the current view as an image.
     * @param format Image format ('png' | 'jpeg' | 'webp')
     * @param quality Quality for jpeg/webp (0-1)
     * @param transparent Use transparent background (only for 'png')
     * @returns Data URL of the image
     */
    exportImage(format?: 'png' | 'jpeg' | 'webp', quality?: number, transparent?: boolean): string;
    /**
     * Export the current view as a Blob.
     * @param format Image format ('png' | 'jpeg' | 'webp')
     * @param quality Quality for jpeg/webp (0-1)
     * @returns Promise that resolves to Blob
     */
    exportImageBlob(format?: 'png' | 'jpeg' | 'webp', quality?: number): Promise<Blob | null>;
    /**
     * Download the current view as an image file.
     * @param filename Filename without extension
     * @param format Image format
     * @param quality Quality for jpeg/webp
     */
    downloadImage(filename?: string, format?: 'png' | 'jpeg' | 'webp', quality?: number): void;
    /**
     * Clean up all resources.
     */
    destroy(): void;
}