export type AssetType = 'texture' | 'audio' | 'mesh' | 'animation' | 'font' | 'data';
export interface CompressionStats {
    originalSize: number;
    compressedSize: number;
    ratio: number;
    duration: number;
    format: string;
}
export interface TextureCompressionConfig {
    format: 'webp' | 'avif' | 'basis' | 'ktx2' | 'png';
    quality: number;
    maxWidth: number;
    maxHeight: number;
    generateMipmaps: boolean;
    premultiplyAlpha: boolean;
    powerOfTwo: boolean;
}
export interface AudioCompressionConfig {
    format: 'opus' | 'aac' | 'mp3' | 'ogg';
    bitrate: number;
    sampleRate: number;
    channels: 1 | 2;
    normalize: boolean;
}
export interface MeshCompressionConfig {
    quantizationBits: number;
    mergeVertices: boolean;
    stripNormals: boolean;
    stripUVs: boolean;
    draco: boolean;
}
export interface AssetManifest {
    version: number;
    assets: AssetEntry[];
    totalOriginalSize: number;
    totalCompressedSize: number;
    compressionRatio: number;
}
export interface AssetEntry {
    id: string;
    type: AssetType;
    originalPath: string;
    compressedPath: string;
    originalSize: number;
    compressedSize: number;
    format: string;
    hash: string;
    metadata?: Record<string, unknown>;
}
export interface StreamingConfig {
    chunkSize: number;
    concurrency: number;
    priorityLevels: number;
    preloadDistance: number;
}
export declare class TextureCompressor {
    private config;
    constructor(config?: Partial<TextureCompressionConfig>);
    compress(imageData: ImageData | HTMLCanvasElement): Promise<{
        blob: Blob;
        stats: CompressionStats;
    }>;
    generateMipmaps(canvas: HTMLCanvasElement): Promise<HTMLCanvasElement[]>;
    private resizeCanvas;
    private ensurePowerOfTwo;
    private getMimeType;
}
export declare class AudioCompressor {
    private config;
    constructor(config?: Partial<AudioCompressionConfig>);
    compress(audioBuffer: AudioBuffer): Promise<{
        blob: Blob;
        stats: CompressionStats;
    }>;
    private resample;
    private normalizeAudio;
    private encodeWAV;
    private writeString;
}
export declare class MeshCompressor {
    private config;
    constructor(config?: Partial<MeshCompressionConfig>);
    compress(vertices: Float32Array, indices: Uint32Array, normals?: Float32Array, uvs?: Float32Array): {
        vertices: Float32Array | Int16Array;
        indices: Uint32Array | Uint16Array;
        normals?: Float32Array | Int8Array;
        uvs?: Float32Array | Uint16Array;
        stats: CompressionStats;
    };
    private quantizeVertices;
    private quantizeNormals;
    private quantizeUVs;
    private mergeVertices;
}
export declare class AssetStreamer {
    private config;
    private activeDownloads;
    private queue;
    private cache;
    constructor(config?: Partial<StreamingConfig>);
    load(url: string, priority?: number): Promise<ArrayBuffer>;
    private processQueue;
    preload(urls: string[], priority?: number): Promise<void[]>;
    evict(url: string): boolean;
    clearCache(): void;
    get cacheSize(): number;
    get pendingDownloads(): number;
}
export declare class AssetPipeline {
    private textureCompressor;
    private audioCompressor;
    private meshCompressor;
    private streamer;
    private manifest;
    constructor(config?: {
        texture?: Partial<TextureCompressionConfig>;
        audio?: Partial<AudioCompressionConfig>;
        mesh?: Partial<MeshCompressionConfig>;
        streaming?: Partial<StreamingConfig>;
    });
    getTextureCompressor(): TextureCompressor;
    getAudioCompressor(): AudioCompressor;
    getMeshCompressor(): MeshCompressor;
    getStreamer(): AssetStreamer;
    getManifest(): Readonly<AssetManifest>;
    addToManifest(entry: AssetEntry): void;
    exportManifest(): string;
    getCompressionSummary(): {
        totalAssets: number;
        byType: Record<string, {
            count: number;
            savedBytes: number;
        }>;
        totalSavedBytes: number;
        overallRatio: number;
    };
}
