/**
 * Zero-Knowledge Proof Verifier
 *
 * Provides proof verification capabilities including:
 * - Fast single proof verification
 * - Batch verification for multiple proofs
 * - Verification result caching
 * - Proof expiration handling
 *
 * This module is designed for high-performance verification scenarios
 * with configurable caching and expiration policies.
 *
 * @packageDocumentation
 */
import { VorionError } from '../../common/errors.js';
import { type ZKProof, type VerificationResult, type BatchVerificationResult, type ZKVerifierConfig, type SerializedZKProof, VerificationErrorCode } from './types.js';
/**
 * Verification error
 */
export declare class VerificationError extends VorionError {
    readonly errorCode: VerificationErrorCode;
    readonly circuit?: string;
    code: string;
    statusCode: number;
    constructor(message: string, errorCode: VerificationErrorCode, circuit?: string, details?: Record<string, unknown>);
}
/**
 * ZK Verifier Service
 *
 * High-performance proof verification with caching and batch support.
 *
 * @example
 * ```typescript
 * const verifier = new ZKVerifierService();
 *
 * // Verify single proof
 * const result = await verifier.verify(proof);
 *
 * // Batch verify
 * const batchResult = await verifier.verifyBatch(proofs);
 * ```
 */
export declare class ZKVerifierService {
    private config;
    private circuitRegistry;
    private cache;
    constructor(config?: Partial<ZKVerifierConfig>);
    /**
     * Verify a single proof
     */
    verify(proof: ZKProof): Promise<VerificationResult>;
    /**
     * Verify multiple proofs in batch
     *
     * Batch verification can be more efficient than individual verification
     * for certain proof systems (e.g., Groth16 with batch pairing checks).
     */
    verifyBatch(proofs: ZKProof[]): Promise<BatchVerificationResult>;
    /**
     * Verify a serialized proof (from storage/transmission)
     */
    verifySerializedProof(serialized: SerializedZKProof): Promise<VerificationResult>;
    /**
     * Check if a proof is expired
     */
    isExpired(proof: ZKProof): boolean;
    /**
     * Get remaining validity time in milliseconds
     */
    getRemainingValidity(proof: ZKProof): number | null;
    /**
     * Clear verification cache
     */
    clearCache(): void;
    /**
     * Get cache statistics
     */
    getCacheStats(): {
        size: number;
        enabled: boolean;
    };
    /**
     * Destroy the service and cleanup resources
     */
    destroy(): void;
    private validateProofStructure;
    /**
     * Perform cryptographic verification of the proof
     *
     * In production, replace with snarkjs verification:
     *
     * ```typescript
     * import * as snarkjs from 'snarkjs';
     *
     * const valid = await snarkjs.groth16.verify(
     *   verificationKey,
     *   proof.publicInputs,
     *   proof.proof
     * );
     * ```
     */
    private verifyProofCrypto;
    private computeVerificationHash;
    private deserializeProof;
    private recordAndReturn;
}
/**
 * Create a new ZK verifier service
 */
export declare function createZKVerifier(config?: Partial<ZKVerifierConfig>): ZKVerifierService;
//# sourceMappingURL=verifier.d.ts.map