/**
 * Zero-Knowledge Proof System for Vorion Security Platform
 *
 * This module provides a comprehensive Zero-Knowledge Proof (ZKP) system for
 * privacy-preserving verification in the Vorion security platform.
 *
 * Features:
 * - Age verification without revealing date of birth
 * - Attribute range proofs (salary, credit score, etc.)
 * - Set membership proofs (allowed lists without revealing identity)
 * - Credential verification with selective disclosure
 * - Compliance verification (KYC, AML, GDPR, PCI-DSS)
 * - Policy engine integration
 * - Session-based proof caching
 *
 * Architecture:
 * - Circuits: Define ZK circuit constraints and witness computation
 * - Prover: Generate cryptographic proofs
 * - Verifier: Verify proofs with caching and batch support
 * - Commitments: Pedersen, Merkle, and accumulator schemes
 * - Compliance: Regulatory compliance verification
 * - SNARK Utils: Trusted setup and key management
 * - Integration: Policy engine integration
 *
 * Usage:
 * ```typescript
 * import {
 *   createZKProver,
 *   createZKVerifier,
 *   ZKCircuitType,
 * } from './security/zkp';
 *
 * // Generate an age proof
 * const prover = createZKProver();
 * const proof = await prover.generateAgeProof(birthDate, 18);
 *
 * // Verify the proof
 * const verifier = createZKVerifier();
 * const result = await verifier.verify(proof);
 *
 * if (result.valid) {
 *   console.log('User is at least 18 years old');
 * }
 * ```
 *
 * Production SNARK Integration:
 * The current implementation uses Schnorr-based proofs for demonstration.
 * For production, integrate with snarkjs/circom:
 *
 * ```typescript
 * import * as snarkjs from 'snarkjs';
 *
 * // Generate proof with snarkjs
 * const { proof, publicSignals } = await snarkjs.groth16.fullProve(
 *   witness,
 *   'circuit.wasm',
 *   'circuit_final.zkey'
 * );
 *
 * // Verify with snarkjs
 * const valid = await snarkjs.groth16.verify(
 *   verificationKey,
 *   publicSignals,
 *   proof
 * );
 * ```
 *
 * @packageDocumentation
 */
export { ZKCircuitType, type CircuitMetadata, zkCircuitTypeSchema, circuitMetadataSchema, type ZKProof, type SerializedZKProof, zkProofSchema, serializedZKProofSchema, type VerificationResult, type BatchVerificationResult, VerificationErrorCode, verificationResultSchema, batchVerificationResultSchema, CommitmentScheme, type Commitment, type MerkleProof, type PedersenCommitment, commitmentSchemeSchema, commitmentSchema, merkleProofSchema, pedersenCommitmentSchema, type ZKCredential, type SelectiveDisclosureRequest, type PredicateProof, zkCredentialSchema, selectiveDisclosureRequestSchema, predicateProofSchema, type ZKProverConfig, type ZKVerifierConfig, DEFAULT_ZK_PROVER_CONFIG, DEFAULT_ZK_VERIFIER_CONFIG, zkProverConfigSchema, zkVerifierConfigSchema, ComplianceVerificationType, type ComplianceProofRequest, type ComplianceVerificationResult, complianceVerificationTypeSchema, complianceProofRequestSchema, complianceVerificationResultSchema, type TrustedSetupParams, type ProvingKey, type VerificationKey, trustedSetupParamsSchema, provingKeySchema, verificationKeySchema, type ZKProofPolicyCondition, type SessionProofCache, zkProofPolicyConditionSchema, sessionProofCacheSchema, } from './types.js';
export { CircuitRegistry, AgeVerificationCircuit, RangeProofCircuit, SetMembershipCircuit, CredentialVerificationCircuit, type Circuit, createCircuitRegistry, getCircuit, CircuitError, } from './circuits.js';
export { ZKProverService, type ZKProver, createZKProver, ProofGenerationError, } from './prover.js';
export { ZKVerifierService, createZKVerifier, VerificationError, } from './verifier.js';
export { PedersenCommitmentService, MerkleTreeService, AccumulatorService, HashCommitmentService, type PedersenOpening, type MerkleTree, type AccumulatorState, type AccumulatorWitness, createCommitmentService, CommitmentError, } from './commitment.js';
export { KYCVerificationService, AMLScreeningService, GDPRComplianceService, PCIDSSVerificationService, type KYCRequirements, type AMLLimits, type GDPRConsentRequirements, type BINRange, createComplianceService, ComplianceError, } from './compliance.js';
export { ProofSerializer, KeyManager, TrustedSetupManager, SNARKIntegration, type ContributionReceipt, createProofSerializer, createKeyManager, createTrustedSetupManager, SNARKError, } from './snark-utils.js';
export { SessionProofCacheManager, ProofRefreshManager, ZKPPolicyConditionEvaluator, type ProofRefreshPolicy, type PolicyConditionResult, type MultiConditionResult, createSessionProofCache, createProofRefreshManager, createZKPPolicyEvaluator, ZKPPolicyError, } from './integration.js';
import { ZKProverService } from './prover.js';
import { ZKVerifierService } from './verifier.js';
import { ZKPPolicyConditionEvaluator } from './integration.js';
import type { ZKProof, VerificationResult, ZKCredential, SelectiveDisclosureRequest } from './types.js';
/**
 * Quick proof generation for common use cases
 */
export declare const ZKP: {
    /**
     * Generate an age verification proof
     *
     * @param birthDate - Date of birth
     * @param minAge - Minimum age to prove
     * @returns ZK proof
     *
     * @example
     * ```typescript
     * const proof = await ZKP.proveAge(new Date('1990-01-15'), 21);
     * ```
     */
    proveAge(birthDate: Date, minAge: number): Promise<ZKProof>;
    /**
     * Generate a range proof
     *
     * @param value - Private value
     * @param min - Range minimum
     * @param max - Range maximum
     * @returns ZK proof
     *
     * @example
     * ```typescript
     * const proof = await ZKP.proveRange(75000, 50000, 100000);
     * ```
     */
    proveRange(value: number, min: number, max: number): Promise<ZKProof>;
    /**
     * Generate a credential proof with selective disclosure
     *
     * @param credential - Full credential
     * @param disclosure - Selective disclosure request
     * @returns ZK proof
     *
     * @example
     * ```typescript
     * const proof = await ZKP.proveCredential(credential, {
     *   reveal: ['name'],
     *   proveExistence: ['age'],
     *   predicates: [{ claim: 'age', operator: 'gte', value: 18 }]
     * });
     * ```
     */
    proveCredential(credential: ZKCredential, disclosure: SelectiveDisclosureRequest): Promise<ZKProof>;
    /**
     * Verify a ZK proof
     *
     * @param proof - Proof to verify
     * @returns Verification result
     *
     * @example
     * ```typescript
     * const result = await ZKP.verify(proof);
     * if (result.valid) {
     *   // Proof is valid
     * }
     * ```
     */
    verify(proof: ZKProof): Promise<VerificationResult>;
    /**
     * Verify multiple proofs in batch
     *
     * @param proofs - Proofs to verify
     * @returns Batch verification result
     */
    verifyBatch(proofs: ZKProof[]): Promise<import("./types.js").BatchVerificationResult>;
};
/**
 * Create a fully configured ZKP system
 *
 * @returns Object with prover, verifier, and policy evaluator
 *
 * @example
 * ```typescript
 * const zkSystem = createZKPSystem();
 *
 * // Generate proof
 * const proof = await zkSystem.prover.generateAgeProof(dob, 18);
 *
 * // Verify
 * const result = await zkSystem.verifier.verify(proof);
 *
 * // Use in policies
 * await zkSystem.policyEvaluator.evaluate(sessionId, condition, proof);
 *
 * // Cleanup
 * zkSystem.destroy();
 * ```
 */
export declare function createZKPSystem(): {
    prover: ZKProverService;
    verifier: ZKVerifierService;
    policyEvaluator: ZKPPolicyConditionEvaluator;
    /**
     * Clean up all resources
     */
    destroy(): void;
};
//# sourceMappingURL=index.d.ts.map