import type { EvidenceCollection } from './evidence-collector.js';
/**
 * Hash entry for a single evidence item
 */
export interface EvidenceHash {
    /** Unique identifier for the evidence item */
    id: string;
    /** Type of evidence */
    type: string;
    /** SHA-256 hash of the evidence content */
    hash: string;
    /** Timestamp when hash was computed */
    computedAt: string;
}
/**
 * Merkle tree proof for evidence verification
 */
export interface EvidenceMerkleProof {
    /** Merkle root hash */
    root: string;
    /** Total number of evidence items (leaves) */
    leafCount: number;
    /** Tree depth */
    treeDepth: number;
    /** Algorithm used */
    algorithm: 'sha256';
    /** Timestamp when tree was built */
    builtAt: string;
}
/**
 * Digital signature for evidence package
 */
export interface EvidenceSignature {
    /** Signature algorithm */
    algorithm: 'RSASSA-PKCS1-v1_5' | 'ECDSA' | 'HMAC-SHA256';
    /** Base64-encoded signature */
    signature: string;
    /** Key identifier used for signing */
    keyId: string;
    /** Timestamp when signed */
    signedAt: string;
    /** Hash of the signed content */
    contentHash: string;
}
/**
 * Complete tamper-evident package
 */
export interface TamperEvidentPackage {
    /** Package version */
    version: string;
    /** Package identifier */
    packageId: string;
    /** Created timestamp */
    createdAt: string;
    /** Individual evidence hashes */
    evidenceHashes: EvidenceHash[];
    /** Merkle tree proof */
    merkleProof: EvidenceMerkleProof;
    /** Digital signature (if signing key available) */
    signature?: EvidenceSignature;
    /** Verification instructions */
    verificationInstructions: VerificationInstructions;
}
/**
 * Instructions for verifying the evidence package
 */
export interface VerificationInstructions {
    /** Steps for manual verification */
    steps: string[];
    /** Algorithm details */
    algorithms: {
        hash: string;
        merkle: string;
        signature?: string;
    };
    /** Sample code for verification */
    sampleCode: {
        language: string;
        code: string;
    };
    /** Contact for verification assistance */
    verificationContact?: string;
}
/**
 * Configuration for the hash verifier
 */
export interface HashVerifierConfig {
    /** Signing key (optional, for digital signatures) */
    signingKey?: CryptoKey;
    /** Signing key ID */
    signingKeyId?: string;
    /** Signing algorithm */
    signatureAlgorithm?: 'RSASSA-PKCS1-v1_5' | 'ECDSA' | 'HMAC-SHA256';
    /** Verification contact email */
    verificationContact?: string;
}
/**
 * Hash Verifier for creating tamper-evident evidence packages
 */
export declare class HashVerifier {
    private readonly version;
    private config;
    constructor(config?: HashVerifierConfig);
    /**
     * Create a tamper-evident package for an evidence collection
     */
    createTamperEvidentPackage(collection: EvidenceCollection): Promise<TamperEvidentPackage>;
    /**
     * Compute SHA-256 hashes for all evidence items
     */
    private computeEvidenceHashes;
    /**
     * Build Merkle tree from evidence hashes
     */
    private buildMerkleProof;
    /**
     * Sign the package using the configured key
     */
    private signPackage;
    /**
     * Generate verification instructions
     */
    private generateVerificationInstructions;
    /**
     * Verify a tamper-evident package
     */
    verifyPackage(evidence: EvidenceCollection, pkg: TamperEvidentPackage): Promise<{
        valid: boolean;
        errors: string[];
        details: {
            hashesVerified: number;
            hashMismatches: string[];
            merkleRootValid: boolean;
            signatureValid?: boolean;
        };
    }>;
    /**
     * Verify a digital signature
     */
    private verifySignature;
    /**
     * Compute SHA-256 hash of arbitrary data
     */
    computeHash(data: string | object): Promise<string>;
    /**
     * Generate a simple hash verification report
     */
    generateHashReport(collection: EvidenceCollection): Promise<{
        collectionId: string;
        totalItems: number;
        hashAlgorithm: string;
        hashes: Array<{
            id: string;
            type: string;
            hash: string;
        }>;
        combinedHash: string;
        generatedAt: string;
    }>;
}
/**
 * Get the singleton hash verifier instance
 */
export declare function getHashVerifier(config?: HashVerifierConfig): HashVerifier;
/**
 * Reset the singleton (for testing)
 */
export declare function resetHashVerifier(): void;
/**
 * Create a new HashVerifier instance with custom config
 */
export declare function createHashVerifier(config?: HashVerifierConfig): HashVerifier;
//# sourceMappingURL=hash-verifier.d.ts.map