/**
 * @holoscript/core LOD Streaming Manager
 *
 * v3.5 LOD Streaming System for high-performance asset streaming.
 * Implements async mesh loading, priority queues, prefetching, and resource budgets.
 */
import type { LODManager } from './LODManager';
import type { MeshData } from './LODGenerator';
export interface StreamingOptions {
    /** Memory budget in bytes (default: 512MB) */
    memoryBudgetBytes: number;
    /** Bandwidth budget in bytes/second (default: 10MB/s) */
    bandwidthBudgetBytesPerSec: number;
    /** Prefetch distance multiplier (default: 2x LOD threshold) */
    prefetchDistanceMultiplier: number;
    /** Maximum concurrent loads (default: 4) */
    maxConcurrentLoads: number;
    /** Enable velocity-based prefetching (default: true) */
    enableVelocityPrefetch: boolean;
    /** Debug logging (default: false) */
    debug: boolean;
}
export declare const DEFAULT_STREAMING_OPTIONS: StreamingOptions;
export interface StreamRequest {
    /** Unique request ID */
    id: string;
    /** Object ID */
    objectId: string;
    /** LOD level to load */
    level: number;
    /** Asset path or URL */
    assetPath: string;
    /** Priority (higher = more important) */
    priority: number;
    /** Request timestamp */
    timestamp: number;
    /** Estimated size in bytes */
    estimatedSize: number;
    /** Distance to camera */
    distance: number;
    /** Screen coverage (0-1) */
    screenCoverage: number;
}
export interface StreamingMetrics {
    /** Total memory used by loaded LODs */
    memoryUsedBytes: number;
    /** Number of LODs currently loaded */
    lodsLoaded: number;
    /** Number of pending requests */
    pendingRequests: number;
    /** Number of active downloads */
    activeLoads: number;
    /** Total bytes downloaded this session */
    totalBytesDownloaded: number;
    /** Current bandwidth usage (bytes/sec) */
    currentBandwidthUsage: number;
    /** Cache hit rate (0-1) */
    cacheHitRate: number;
    /** Average load time (ms) */
    averageLoadTimeMs: number;
}
export type StreamEventType = 'loadStart' | 'loadComplete' | 'loadError' | 'budgetExceeded' | 'prefetchStart';
export interface StreamEvent {
    type: StreamEventType;
    objectId: string;
    level: number;
    timestamp: number;
    size?: number;
    error?: Error;
}
export type StreamEventHandler = (event: StreamEvent) => void;
export declare class LODStreamingManager {
    private options;
    private requestQueue;
    private activeLoads;
    private loadedMeshes;
    private eventHandlers;
    private metrics;
    private lodManager;
    private cameraPosition;
    private previousCameraPosition;
    private cameraVelocity;
    private lastUpdateTime;
    private bandwidthWindow;
    constructor(options?: Partial<StreamingOptions>);
    /**
     * Attach to LOD manager for integration
     */
    attachLODManager(manager: LODManager): void;
    /**
     * Set camera position and update velocity
     */
    setCameraPosition(position: [number, number, number], deltaTime?: number): void;
    /**
     * Request LOD mesh for streaming
     */
    requestLOD(objectId: string, level: number, assetPath: string, distance: number, screenCoverage: number, estimatedSize: number): void;
    /**
     * Cancel a streaming request
     */
    cancelRequest(objectId: string, level: number): void;
    /**
     * Get loaded mesh data
     */
    getMesh(objectId: string, level: number): MeshData | undefined;
    /**
     * Check if mesh is loaded
     */
    isLoaded(objectId: string, level: number): boolean;
    /**
     * Check if mesh is loading
     */
    isLoading(objectId: string, level: number): boolean;
    /**
     * Update streaming system (call each frame)
     */
    update(_deltaTime?: number): Promise<void>;
    /**
     * Process request queue
     */
    private processQueue;
    /**
     * Start loading a mesh
     */
    private startLoad;
    /**
     * Load mesh data from path/URL (async)
     */
    private loadMeshData;
    /**
     * Process velocity-based prefetching
     */
    private processPrefetching;
    /**
     * Predict distance based on camera velocity
     */
    private predictDistance;
    /**
     * Select LOD level by distance (matches LODManager logic)
     */
    private selectLODByDistance;
    private createMetrics;
    private updateMetrics;
    getMetrics(): StreamingMetrics;
    on(eventType: StreamEventType, handler: StreamEventHandler): () => void;
    private emit;
    /**
     * Unload a specific LOD level
     */
    unload(objectId: string, level: number): void;
    /**
     * Clear all loaded meshes and pending requests
     */
    clear(): void;
    /**
     * Get current options
     */
    getOptions(): StreamingOptions;
    /**
     * Update options
     */
    setOptions(options: Partial<StreamingOptions>): void;
}
/**
 * Create streaming manager with default options
 */
export declare function createStreamingManager(options?: Partial<StreamingOptions>): LODStreamingManager;
/**
 * Create streaming manager optimized for mobile
 */
export declare function createMobileStreamingManager(): LODStreamingManager;
/**
 * Create streaming manager optimized for desktop/high-end
 */
export declare function createDesktopStreamingManager(): LODStreamingManager;
//# sourceMappingURL=LODStreamingManager.d.ts.map