/**
 * Compliance Use Cases for Zero-Knowledge Proofs
 *
 * Implements privacy-preserving compliance verification for:
 * - KYC without data sharing
 * - AML screening proofs
 * - GDPR-compliant verification
 * - PCI-DSS cardholder verification
 *
 * These use cases enable regulatory compliance while preserving user privacy
 * through selective disclosure and zero-knowledge proofs.
 *
 * @packageDocumentation
 */
import { VorionError } from '../../common/errors.js';
import { type ZKCredential, type ComplianceVerificationResult, ComplianceVerificationType } from './types.js';
import { ZKProverService } from './prover.js';
import { ZKVerifierService } from './verifier.js';
/**
 * Compliance verification error
 */
export declare class ComplianceError extends VorionError {
    readonly verificationType: ComplianceVerificationType;
    code: string;
    statusCode: number;
    constructor(message: string, verificationType: ComplianceVerificationType, details?: Record<string, unknown>);
}
/**
 * KYC (Know Your Customer) Verification Service
 *
 * Enables identity verification without sharing actual identity documents.
 * Users prove they have been KYC-verified by a trusted issuer without
 * revealing their personal information.
 *
 * Supported proofs:
 * - Identity verified by issuer
 * - Age verification (e.g., over 18)
 * - Jurisdiction verification
 * - Sanctions list clearance
 *
 * @example
 * ```typescript
 * const kyc = new KYCVerificationService();
 *
 * // Verify age requirement without revealing DOB
 * const result = await kyc.verifyAgeRequirement(credential, 18);
 *
 * // Verify identity without revealing PII
 * const idResult = await kyc.verifyIdentity(credential, {
 *   requiredIssuer: 'did:example:trusted-issuer',
 *   requiredLevel: 'enhanced'
 * });
 * ```
 */
export declare class KYCVerificationService {
    private prover;
    private verifier;
    constructor(prover?: ZKProverService, verifier?: ZKVerifierService);
    /**
     * Verify age requirement using ZK proof
     *
     * Proves user is at least `minAge` years old without revealing date of birth.
     */
    verifyAgeRequirement(credential: ZKCredential, minAge: number): Promise<ComplianceVerificationResult>;
    /**
     * Verify identity credential without revealing PII
     */
    verifyIdentity(credential: ZKCredential, requirements: KYCRequirements): Promise<ComplianceVerificationResult>;
    /**
     * Generate compliance attestation
     */
    private generateAttestation;
    private createFailedResult;
}
/**
 * KYC verification requirements
 */
export interface KYCRequirements {
    /** Required credential issuer DID */
    requiredIssuer?: string;
    /** Required verification level */
    requiredLevel?: 'basic' | 'standard' | 'enhanced';
    /** Claims that must exist in credential */
    requiredClaims?: string[];
    /** Claims to reveal (selective disclosure) */
    revealClaims?: string[];
}
/**
 * AML (Anti-Money Laundering) Screening Service
 *
 * Enables AML compliance verification without revealing transaction details
 * or user identity. Uses set membership proofs to verify users are not
 * on sanctions lists without revealing which list or the user's identity.
 *
 * @example
 * ```typescript
 * const aml = new AMLScreeningService();
 *
 * // Prove not on sanctions list
 * const result = await aml.proveNotOnSanctionsList(userId, listCommitment);
 *
 * // Verify transaction compliance
 * const txResult = await aml.verifyTransaction(transaction, limits);
 * ```
 */
export declare class AMLScreeningService {
    private prover;
    private verifier;
    private merkleService;
    private accumulatorService;
    constructor(prover?: ZKProverService, verifier?: ZKVerifierService);
    /**
     * Prove user is not on a sanctions list
     *
     * Uses a privacy-preserving approach where:
     * 1. A "cleared users" set is maintained
     * 2. Users prove membership in the cleared set
     * 3. No information about the sanctions list is revealed
     */
    proveSanctionsCleared(userId: string, clearedSetCommitment: string, membershipProof: {
        siblings: string[];
        pathIndices: number[];
        leafIndex: number;
    }): Promise<ComplianceVerificationResult>;
    /**
     * Verify transaction amount is within limits
     *
     * Proves transaction is below reporting threshold without revealing amount.
     */
    verifyTransactionCompliance(transactionAmount: number, dailyTotal: number, limits: AMLLimits): Promise<ComplianceVerificationResult>;
    private generateAttestation;
}
/**
 * AML transaction limits
 */
export interface AMLLimits {
    /** Single transaction limit */
    singleTransactionLimit: number;
    /** Daily cumulative limit */
    dailyLimit: number;
    /** Monthly limit (optional) */
    monthlyLimit?: number;
}
/**
 * GDPR Compliance Verification Service
 *
 * Enables GDPR-compliant data processing verification:
 * - Data subject identity verification without revealing identity
 * - Consent verification
 * - Right to access/erasure verification
 * - Data minimization proofs
 *
 * @example
 * ```typescript
 * const gdpr = new GDPRComplianceService();
 *
 * // Verify data subject without revealing identity
 * const result = await gdpr.verifyDataSubject(subjectProof);
 *
 * // Verify consent for processing
 * const consentResult = await gdpr.verifyConsent(consentCredential, purpose);
 * ```
 */
export declare class GDPRComplianceService {
    private prover;
    private verifier;
    constructor(prover?: ZKProverService, verifier?: ZKVerifierService);
    /**
     * Verify data subject without revealing their identity
     *
     * Proves the requester is the data subject without revealing PII.
     */
    verifyDataSubject(credential: ZKCredential, dataSubjectCommitment: string): Promise<ComplianceVerificationResult>;
    /**
     * Verify consent for data processing
     *
     * Proves valid consent exists for a specific processing purpose.
     */
    verifyConsent(consentCredential: ZKCredential, purpose: string, requirements: GDPRConsentRequirements): Promise<ComplianceVerificationResult>;
    /**
     * Verify right to erasure request
     */
    verifyErasureRequest(credential: ZKCredential, dataSubjectCommitment: string): Promise<ComplianceVerificationResult>;
    private generateAttestation;
    private createFailedResult;
}
/**
 * GDPR consent requirements
 */
export interface GDPRConsentRequirements {
    /** Required jurisdiction (e.g., 'EU') */
    requiredJurisdiction?: string;
    /** Minimum consent age */
    minConsentAge?: number;
    /** Whether explicit consent is required */
    explicitConsentRequired?: boolean;
}
/**
 * PCI-DSS Cardholder Verification Service
 *
 * Enables PCI-DSS compliant cardholder verification without exposing card data:
 * - Verify card ownership without revealing card number
 * - Verify transaction authorization
 * - Prove cardholder identity
 *
 * @example
 * ```typescript
 * const pci = new PCIDSSVerificationService();
 *
 * // Verify cardholder without revealing PAN
 * const result = await pci.verifyCardholder(credential, merchantId);
 * ```
 */
export declare class PCIDSSVerificationService {
    private prover;
    private verifier;
    constructor(prover?: ZKProverService, verifier?: ZKVerifierService);
    /**
     * Verify cardholder without revealing card number
     *
     * Proves:
     * 1. Possession of a valid card issued by a trusted issuer
     * 2. Card is not expired
     * 3. Card matches the cardholder (optional additional verification)
     */
    verifyCardholder(cardCredential: ZKCredential, merchantId: string): Promise<ComplianceVerificationResult>;
    /**
     * Verify card BIN is in allowed range
     *
     * Proves card is from an accepted network/issuer without revealing full PAN.
     */
    verifyCardBINRange(cardCredential: ZKCredential, allowedBINRanges: BINRange[]): Promise<ComplianceVerificationResult>;
    private generateAttestation;
    private createFailedResult;
}
/**
 * BIN (Bank Identification Number) range
 */
export interface BINRange {
    /** Start of range (inclusive) */
    start: number;
    /** End of range (inclusive) */
    end: number;
    /** Network name (e.g., 'Visa', 'Mastercard') */
    network?: string;
}
/**
 * Create a compliance verification service for the specified type
 */
export declare function createComplianceService(type: ComplianceVerificationType, prover?: ZKProverService, verifier?: ZKVerifierService): KYCVerificationService | AMLScreeningService | GDPRComplianceService | PCIDSSVerificationService;
//# sourceMappingURL=compliance.d.ts.map