import * as THREE from 'three';

/**
 * @epochcore/quantum-hdr-watermark
 * Unforgeable Three.js watermarking with quantum coherence verification
 *
 * Protected by EpochCore QuantumSeal Technology
 * RAS Root: 40668c787c463ca5
 * Waterseal: 63162c58-8312-47f1-a3b3-631fb4a10477
 */

/**
 * Minimal interface for QaaSClient QRNG integration.
 * Accepts any object with generateQuantumFloats() — avoids hard dependency.
 */
interface QRNGProvider {
    generateQuantumFloats(count: number): Promise<number[]>;
}
interface QuantumWatermarkConfig {
    /** Quantum seal identifier */
    quantumSeal: string;
    /** RAS root for verification */
    rasRoot: string;
    /** Waterseal ID for tamper detection */
    waterseal: string;
    /** Target coherence (default: 0.999999) */
    coherence?: number;
    /** Protection level */
    protectionLevel?: 'STANDARD' | 'ENHANCED' | 'MAXIMUM';
    /** Creator signature */
    creator?: string;
    /** Optional QRNG provider for true quantum noise (e.g. QaaSClient from @epochcore/qaas-sdk) */
    qrngProvider?: QRNGProvider;
}
interface WatermarkMetadata {
    signature: string;
    timestamp: string;
    quantumHash: string;
    coherence: number;
    verificationUrl: string;
    entropy_source: 'IBM_QUANTUM' | 'CLASSICAL_HMAC';
}
declare class QuantumHDRWatermark {
    private config;
    private readonly qrngProvider?;
    private readonly INFINITY_CAPSULE_SIGNATURE;
    private readonly QUANTUM_VERIFICATION_COHERENCE;
    private quantumNoiseCache;
    constructor(config: QuantumWatermarkConfig);
    /**
     * Embed quantum watermark into Three.js scene (synchronous, HMAC noise).
     * For true quantum noise, use embedSceneAsync() instead.
     */
    embedScene(scene: THREE.Scene): WatermarkMetadata;
    /**
     * Embed quantum watermark with real IBM Quantum QRNG noise.
     * Requires a qrngProvider in the constructor config.
     * Falls back to HMAC noise if QRNG fetch fails.
     */
    embedSceneAsync(scene: THREE.Scene): Promise<WatermarkMetadata>;
    private _embedSceneInternal;
    /**
     * Embed watermark into texture (UltraHDR format)
     */
    embedTexture(texture: THREE.Texture): WatermarkMetadata;
    /**
     * Verify watermark integrity
     */
    verify(scene: THREE.Scene): {
        verified: boolean;
        coherence: number;
        metadata?: any;
        tampered: boolean;
    };
    /**
     * Generate quantum hash for scene
     */
    private generateQuantumHash;
    /**
     * Generate texture hash
     */
    private generateTextureHash;
    /**
     * Hash scene geometry and materials
     */
    private hashScene;
    /**
     * Embed watermark in mesh geometry (imperceptible modification)
     */
    private embedMeshWatermark;
    /**
     * Apply imperceptible quantum noise to geometry.
     * Uses true IBM Quantum QRNG noise when available, HMAC-based PRNG otherwise.
     */
    private applyQuantumNoise;
    /**
     * Embed metadata in HDR texture
     */
    private embedHDRMetadata;
    /**
     * Calculate scene coherence
     */
    private calculateCoherence;
    /**
     * HMAC-based deterministic random number generator (unpredictable without quantumSeal)
     */
    private quantumRandom;
    /**
     * Deterministic JSON serialization with sorted keys
     */
    private deterministicStringify;
}
/**
 * Quick watermark embed function (synchronous, HMAC noise)
 */
declare function embedWatermark(scene: THREE.Scene, config: QuantumWatermarkConfig): WatermarkMetadata;
/**
 * Quick watermark embed with real IBM Quantum QRNG noise.
 * Requires qrngProvider in config.
 */
declare function embedWatermarkAsync(scene: THREE.Scene, config: QuantumWatermarkConfig): Promise<WatermarkMetadata>;
/**
 * Quick verify function
 */
declare function verifyWatermark(scene: THREE.Scene, config: QuantumWatermarkConfig): {
    verified: boolean;
    coherence: number;
    metadata?: any;
    tampered: boolean;
};
declare const INFINITY_CAPSULE: {
    creator: string;
    integrity: string;
    components: {
        UltraHDR: {
            author: string;
            signature: string;
            protection: string;
        };
        quantum_additions: {
            architect: string;
            verified_by: string;
            components: string[];
        };
    };
    fusion: {
        method: string;
        verification: string;
        timestamp: string;
    };
    capsule_seal: {
        primary: string;
        secondary: string;
        integrity_hash: string;
    };
};

export { INFINITY_CAPSULE, type QRNGProvider, QuantumHDRWatermark, type QuantumWatermarkConfig, type WatermarkMetadata, embedWatermark, embedWatermarkAsync, verifyWatermark };