/**
 * Zero-Knowledge Proof Type Definitions
 *
 * Core type definitions for the ZKP system including proofs, verification results,
 * circuit definitions, and commitment schemes.
 *
 * This module follows the Vorion type definition patterns and integrates
 * with the existing security infrastructure.
 *
 * @packageDocumentation
 */
import { z } from 'zod';
/**
 * Supported ZK circuit types
 */
export declare const ZKCircuitType: {
    /** Age verification without revealing date of birth */
    readonly AGE_VERIFICATION: "age_verification";
    /** Prove a value is within a range without revealing the value */
    readonly RANGE_PROOF: "range_proof";
    /** Prove membership in a set without revealing which element */
    readonly SET_MEMBERSHIP: "set_membership";
    /** Prove possession of a valid credential without revealing it */
    readonly CREDENTIAL_VERIFICATION: "credential_verification";
    /** Custom circuit for extensibility */
    readonly CUSTOM: "custom";
};
export type ZKCircuitType = (typeof ZKCircuitType)[keyof typeof ZKCircuitType];
export declare const zkCircuitTypeSchema: z.ZodNativeEnum<{
    /** Age verification without revealing date of birth */
    readonly AGE_VERIFICATION: "age_verification";
    /** Prove a value is within a range without revealing the value */
    readonly RANGE_PROOF: "range_proof";
    /** Prove membership in a set without revealing which element */
    readonly SET_MEMBERSHIP: "set_membership";
    /** Prove possession of a valid credential without revealing it */
    readonly CREDENTIAL_VERIFICATION: "credential_verification";
    /** Custom circuit for extensibility */
    readonly CUSTOM: "custom";
}>;
/**
 * Circuit metadata for registration and discovery
 */
export interface CircuitMetadata {
    /** Circuit type identifier */
    type: ZKCircuitType;
    /** Human-readable name */
    name: string;
    /** Circuit description */
    description: string;
    /** Version string (semver) */
    version: string;
    /** Expected public inputs */
    publicInputs: string[];
    /** Expected private inputs (for documentation) */
    privateInputs: string[];
    /** Verification key hash for integrity */
    verificationKeyHash?: string;
    /** When the circuit was registered */
    registeredAt: Date;
}
export declare const circuitMetadataSchema: z.ZodObject<{
    type: z.ZodNativeEnum<{
        /** Age verification without revealing date of birth */
        readonly AGE_VERIFICATION: "age_verification";
        /** Prove a value is within a range without revealing the value */
        readonly RANGE_PROOF: "range_proof";
        /** Prove membership in a set without revealing which element */
        readonly SET_MEMBERSHIP: "set_membership";
        /** Prove possession of a valid credential without revealing it */
        readonly CREDENTIAL_VERIFICATION: "credential_verification";
        /** Custom circuit for extensibility */
        readonly CUSTOM: "custom";
    }>;
    name: z.ZodString;
    description: z.ZodString;
    version: z.ZodString;
    publicInputs: z.ZodArray<z.ZodString, "many">;
    privateInputs: z.ZodArray<z.ZodString, "many">;
    verificationKeyHash: z.ZodOptional<z.ZodString>;
    registeredAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    type?: "custom" | "age_verification" | "range_proof" | "set_membership" | "credential_verification";
    name?: string;
    version?: string;
    description?: string;
    publicInputs?: string[];
    privateInputs?: string[];
    verificationKeyHash?: string;
    registeredAt?: Date;
}, {
    type?: "custom" | "age_verification" | "range_proof" | "set_membership" | "credential_verification";
    name?: string;
    version?: string;
    description?: string;
    publicInputs?: string[];
    privateInputs?: string[];
    verificationKeyHash?: string;
    registeredAt?: Date;
}>;
/**
 * Zero-Knowledge Proof structure
 *
 * Represents a cryptographic proof that can be verified without revealing
 * the underlying secret data.
 *
 * @example
 * ```typescript
 * const proof: ZKProof = {
 *   proof: new Uint8Array([...]),
 *   publicInputs: ['18', 'age_threshold'],
 *   circuit: 'age_verification',
 *   timestamp: new Date(),
 *   expiresAt: new Date(Date.now() + 3600000),
 *   metadata: { purpose: 'kyc_verification' }
 * };
 * ```
 */
export interface ZKProof {
    /** The cryptographic proof bytes */
    proof: Uint8Array;
    /** Public inputs that are revealed as part of the proof */
    publicInputs: string[];
    /** Circuit identifier used to generate the proof */
    circuit: string;
    /** When the proof was generated */
    timestamp: Date;
    /** Optional expiration time for the proof */
    expiresAt?: Date;
    /** Optional metadata for tracking and auditing */
    metadata?: Record<string, unknown>;
    /** Proof format version for compatibility */
    version?: string;
    /** Unique proof identifier for tracking */
    proofId?: string;
}
export declare const zkProofSchema: z.ZodObject<{
    proof: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
    publicInputs: z.ZodArray<z.ZodString, "many">;
    circuit: z.ZodString;
    timestamp: z.ZodDate;
    expiresAt: z.ZodOptional<z.ZodDate>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    version: z.ZodOptional<z.ZodString>;
    proofId: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    expiresAt?: Date;
    version?: string;
    timestamp?: Date;
    proof?: Uint8Array<ArrayBuffer>;
    metadata?: Record<string, unknown>;
    publicInputs?: string[];
    circuit?: string;
    proofId?: string;
}, {
    expiresAt?: Date;
    version?: string;
    timestamp?: Date;
    proof?: Uint8Array<ArrayBuffer>;
    metadata?: Record<string, unknown>;
    publicInputs?: string[];
    circuit?: string;
    proofId?: string;
}>;
/**
 * Serializable proof format for storage and transmission
 */
export interface SerializedZKProof {
    /** Base64-encoded proof bytes */
    proof: string;
    /** Public inputs */
    publicInputs: string[];
    /** Circuit identifier */
    circuit: string;
    /** ISO timestamp when proof was generated */
    timestamp: string;
    /** ISO timestamp when proof expires */
    expiresAt?: string;
    /** Additional metadata */
    metadata?: Record<string, unknown>;
    /** Proof format version */
    version?: string;
    /** Unique proof identifier */
    proofId?: string;
}
export declare const serializedZKProofSchema: z.ZodObject<{
    proof: z.ZodString;
    publicInputs: z.ZodArray<z.ZodString, "many">;
    circuit: z.ZodString;
    timestamp: z.ZodString;
    expiresAt: z.ZodOptional<z.ZodString>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    version: z.ZodOptional<z.ZodString>;
    proofId: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    expiresAt?: string;
    version?: string;
    timestamp?: string;
    proof?: string;
    metadata?: Record<string, unknown>;
    publicInputs?: string[];
    circuit?: string;
    proofId?: string;
}, {
    expiresAt?: string;
    version?: string;
    timestamp?: string;
    proof?: string;
    metadata?: Record<string, unknown>;
    publicInputs?: string[];
    circuit?: string;
    proofId?: string;
}>;
/**
 * Result of proof verification
 *
 * Contains the verification outcome along with metadata about the verification process.
 */
export interface VerificationResult {
    /** Whether the proof is valid */
    valid: boolean;
    /** Circuit used for verification */
    circuit: string;
    /** When verification was performed */
    verifiedAt: Date;
    /** Public inputs that were verified */
    publicInputs: string[];
    /** Verification error message if invalid */
    error?: string;
    /** Error code for programmatic handling */
    errorCode?: VerificationErrorCode;
    /** Time taken to verify in milliseconds */
    verificationTimeMs?: number;
    /** Whether result was retrieved from cache */
    fromCache?: boolean;
    /** Cache entry expiration if cached */
    cacheExpiresAt?: Date;
}
export declare const verificationResultSchema: z.ZodObject<{
    valid: z.ZodBoolean;
    circuit: z.ZodString;
    verifiedAt: z.ZodDate;
    publicInputs: z.ZodArray<z.ZodString, "many">;
    error: z.ZodOptional<z.ZodString>;
    errorCode: z.ZodOptional<z.ZodString>;
    verificationTimeMs: z.ZodOptional<z.ZodNumber>;
    fromCache: z.ZodOptional<z.ZodBoolean>;
    cacheExpiresAt: z.ZodOptional<z.ZodDate>;
}, "strip", z.ZodTypeAny, {
    valid?: boolean;
    error?: string;
    errorCode?: string;
    fromCache?: boolean;
    publicInputs?: string[];
    circuit?: string;
    verifiedAt?: Date;
    verificationTimeMs?: number;
    cacheExpiresAt?: Date;
}, {
    valid?: boolean;
    error?: string;
    errorCode?: string;
    fromCache?: boolean;
    publicInputs?: string[];
    circuit?: string;
    verifiedAt?: Date;
    verificationTimeMs?: number;
    cacheExpiresAt?: Date;
}>;
/**
 * Verification error codes for programmatic handling
 */
export declare const VerificationErrorCode: {
    /** Proof structure is invalid */
    readonly INVALID_PROOF_FORMAT: "INVALID_PROOF_FORMAT";
    /** Circuit not found or not registered */
    readonly UNKNOWN_CIRCUIT: "UNKNOWN_CIRCUIT";
    /** Proof has expired */
    readonly PROOF_EXPIRED: "PROOF_EXPIRED";
    /** Cryptographic verification failed */
    readonly VERIFICATION_FAILED: "VERIFICATION_FAILED";
    /** Public inputs don't match expected format */
    readonly INVALID_PUBLIC_INPUTS: "INVALID_PUBLIC_INPUTS";
    /** Verification key not found */
    readonly MISSING_VERIFICATION_KEY: "MISSING_VERIFICATION_KEY";
    /** Internal verification error */
    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
};
export type VerificationErrorCode = (typeof VerificationErrorCode)[keyof typeof VerificationErrorCode];
/**
 * Batch verification result for multiple proofs
 */
export interface BatchVerificationResult {
    /** All proofs valid */
    allValid: boolean;
    /** Number of proofs verified */
    totalProofs: number;
    /** Number of valid proofs */
    validProofs: number;
    /** Individual verification results */
    results: VerificationResult[];
    /** Total verification time in milliseconds */
    totalTimeMs: number;
    /** When batch verification completed */
    completedAt: Date;
}
export declare const batchVerificationResultSchema: z.ZodObject<{
    allValid: z.ZodBoolean;
    totalProofs: z.ZodNumber;
    validProofs: z.ZodNumber;
    results: z.ZodArray<z.ZodObject<{
        valid: z.ZodBoolean;
        circuit: z.ZodString;
        verifiedAt: z.ZodDate;
        publicInputs: z.ZodArray<z.ZodString, "many">;
        error: z.ZodOptional<z.ZodString>;
        errorCode: z.ZodOptional<z.ZodString>;
        verificationTimeMs: z.ZodOptional<z.ZodNumber>;
        fromCache: z.ZodOptional<z.ZodBoolean>;
        cacheExpiresAt: z.ZodOptional<z.ZodDate>;
    }, "strip", z.ZodTypeAny, {
        valid?: boolean;
        error?: string;
        errorCode?: string;
        fromCache?: boolean;
        publicInputs?: string[];
        circuit?: string;
        verifiedAt?: Date;
        verificationTimeMs?: number;
        cacheExpiresAt?: Date;
    }, {
        valid?: boolean;
        error?: string;
        errorCode?: string;
        fromCache?: boolean;
        publicInputs?: string[];
        circuit?: string;
        verifiedAt?: Date;
        verificationTimeMs?: number;
        cacheExpiresAt?: Date;
    }>, "many">;
    totalTimeMs: z.ZodNumber;
    completedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    totalTimeMs?: number;
    results?: {
        valid?: boolean;
        error?: string;
        errorCode?: string;
        fromCache?: boolean;
        publicInputs?: string[];
        circuit?: string;
        verifiedAt?: Date;
        verificationTimeMs?: number;
        cacheExpiresAt?: Date;
    }[];
    allValid?: boolean;
    totalProofs?: number;
    validProofs?: number;
    completedAt?: Date;
}, {
    totalTimeMs?: number;
    results?: {
        valid?: boolean;
        error?: string;
        errorCode?: string;
        fromCache?: boolean;
        publicInputs?: string[];
        circuit?: string;
        verifiedAt?: Date;
        verificationTimeMs?: number;
        cacheExpiresAt?: Date;
    }[];
    allValid?: boolean;
    totalProofs?: number;
    validProofs?: number;
    completedAt?: Date;
}>;
/**
 * Commitment scheme types
 */
export declare const CommitmentScheme: {
    /** Pedersen commitment (additively homomorphic) */
    readonly PEDERSEN: "pedersen";
    /** Merkle tree commitment (for set membership) */
    readonly MERKLE: "merkle";
    /** Cryptographic accumulator (for dynamic sets) */
    readonly ACCUMULATOR: "accumulator";
    /** Hash commitment (simple binding) */
    readonly HASH: "hash";
};
export type CommitmentScheme = (typeof CommitmentScheme)[keyof typeof CommitmentScheme];
export declare const commitmentSchemeSchema: z.ZodNativeEnum<{
    /** Pedersen commitment (additively homomorphic) */
    readonly PEDERSEN: "pedersen";
    /** Merkle tree commitment (for set membership) */
    readonly MERKLE: "merkle";
    /** Cryptographic accumulator (for dynamic sets) */
    readonly ACCUMULATOR: "accumulator";
    /** Hash commitment (simple binding) */
    readonly HASH: "hash";
}>;
/**
 * Generic commitment structure
 */
export interface Commitment {
    /** Commitment scheme used */
    scheme: CommitmentScheme;
    /** The commitment value (hash or group element) */
    value: string;
    /** Optional blinding factor (for opening proofs) */
    blindingFactor?: string;
    /** When the commitment was created */
    createdAt: Date;
    /** Additional scheme-specific parameters */
    parameters?: Record<string, unknown>;
}
export declare const commitmentSchema: z.ZodObject<{
    scheme: z.ZodNativeEnum<{
        /** Pedersen commitment (additively homomorphic) */
        readonly PEDERSEN: "pedersen";
        /** Merkle tree commitment (for set membership) */
        readonly MERKLE: "merkle";
        /** Cryptographic accumulator (for dynamic sets) */
        readonly ACCUMULATOR: "accumulator";
        /** Hash commitment (simple binding) */
        readonly HASH: "hash";
    }>;
    value: z.ZodString;
    blindingFactor: z.ZodOptional<z.ZodString>;
    createdAt: z.ZodDate;
    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    value?: string;
    createdAt?: Date;
    scheme?: "hash" | "pedersen" | "merkle" | "accumulator";
    blindingFactor?: string;
    parameters?: Record<string, unknown>;
}, {
    value?: string;
    createdAt?: Date;
    scheme?: "hash" | "pedersen" | "merkle" | "accumulator";
    blindingFactor?: string;
    parameters?: Record<string, unknown>;
}>;
/**
 * Merkle tree proof for set membership
 */
export interface MerkleProof {
    /** The leaf value being proven */
    leaf: string;
    /** The Merkle root */
    root: string;
    /** Sibling hashes along the path */
    siblings: string[];
    /** Path indices (left=0, right=1) */
    pathIndices: number[];
    /** Leaf index in the tree */
    leafIndex: number;
}
export declare const merkleProofSchema: z.ZodObject<{
    leaf: z.ZodString;
    root: z.ZodString;
    siblings: z.ZodArray<z.ZodString, "many">;
    pathIndices: z.ZodArray<z.ZodNumber, "many">;
    leafIndex: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    leaf?: string;
    root?: string;
    siblings?: string[];
    pathIndices?: number[];
    leafIndex?: number;
}, {
    leaf?: string;
    root?: string;
    siblings?: string[];
    pathIndices?: number[];
    leafIndex?: number;
}>;
/**
 * Pedersen commitment with opening
 */
export interface PedersenCommitment {
    /** The commitment C = g^v * h^r */
    commitment: string;
    /** Generator g (public parameter) */
    generatorG: string;
    /** Generator h (public parameter) */
    generatorH: string;
    /** Value being committed (private) */
    value?: string;
    /** Blinding factor r (private) */
    blindingFactor?: string;
}
export declare const pedersenCommitmentSchema: z.ZodObject<{
    commitment: z.ZodString;
    generatorG: z.ZodString;
    generatorH: z.ZodString;
    value: z.ZodOptional<z.ZodString>;
    blindingFactor: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    value?: string;
    blindingFactor?: string;
    commitment?: string;
    generatorG?: string;
    generatorH?: string;
}, {
    value?: string;
    blindingFactor?: string;
    commitment?: string;
    generatorG?: string;
    generatorH?: string;
}>;
/**
 * Credential for ZK credential proofs
 */
export interface ZKCredential {
    /** Credential identifier */
    id: string;
    /** Credential issuer DID */
    issuer: string;
    /** Credential subject DID */
    subject: string;
    /** Credential type (e.g., 'AgeCredential', 'EmploymentCredential') */
    type: string;
    /** Credential claims (attribute-value pairs) */
    claims: Record<string, unknown>;
    /** Credential issuance date */
    issuedAt: Date;
    /** Credential expiration date */
    expiresAt?: Date;
    /** Issuer signature over the credential */
    signature: string;
    /** Revocation status commitment (for efficient revocation checks) */
    revocationCommitment?: string;
}
export declare const zkCredentialSchema: z.ZodObject<{
    id: z.ZodString;
    issuer: z.ZodString;
    subject: z.ZodString;
    type: z.ZodString;
    claims: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    issuedAt: z.ZodDate;
    expiresAt: z.ZodOptional<z.ZodDate>;
    signature: z.ZodString;
    revocationCommitment: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    id?: string;
    type?: string;
    expiresAt?: Date;
    issuer?: string;
    claims?: Record<string, unknown>;
    subject?: string;
    signature?: string;
    issuedAt?: Date;
    revocationCommitment?: string;
}, {
    id?: string;
    type?: string;
    expiresAt?: Date;
    issuer?: string;
    claims?: Record<string, unknown>;
    subject?: string;
    signature?: string;
    issuedAt?: Date;
    revocationCommitment?: string;
}>;
/**
 * Selective disclosure request for credential proofs
 */
export interface SelectiveDisclosureRequest {
    /** Claims to prove (without revealing values) */
    proveExistence: string[];
    /** Claims to reveal */
    reveal: string[];
    /** Predicate proofs (e.g., age > 18) */
    predicates: PredicateProof[];
}
export declare const selectiveDisclosureRequestSchema: z.ZodObject<{
    proveExistence: z.ZodArray<z.ZodString, "many">;
    reveal: z.ZodArray<z.ZodString, "many">;
    predicates: z.ZodArray<z.ZodLazy<z.ZodObject<{
        claim: z.ZodString;
        operator: z.ZodEnum<["gt", "gte", "lt", "lte", "eq", "neq", "in", "not_in"]>;
        value: z.ZodUnknown;
    }, "strip", z.ZodTypeAny, {
        value?: unknown;
        claim?: string;
        operator?: "in" | "not_in" | "gte" | "gt" | "lte" | "lt" | "eq" | "neq";
    }, {
        value?: unknown;
        claim?: string;
        operator?: "in" | "not_in" | "gte" | "gt" | "lte" | "lt" | "eq" | "neq";
    }>>, "many">;
}, "strip", z.ZodTypeAny, {
    proveExistence?: string[];
    reveal?: string[];
    predicates?: {
        value?: unknown;
        claim?: string;
        operator?: "in" | "not_in" | "gte" | "gt" | "lte" | "lt" | "eq" | "neq";
    }[];
}, {
    proveExistence?: string[];
    reveal?: string[];
    predicates?: {
        value?: unknown;
        claim?: string;
        operator?: "in" | "not_in" | "gte" | "gt" | "lte" | "lt" | "eq" | "neq";
    }[];
}>;
/**
 * Predicate proof for range/comparison proofs
 */
export interface PredicateProof {
    /** Claim name */
    claim: string;
    /** Comparison operator */
    operator: 'gt' | 'gte' | 'lt' | 'lte' | 'eq' | 'neq' | 'in' | 'not_in';
    /** Comparison value */
    value: unknown;
}
export declare const predicateProofSchema: z.ZodObject<{
    claim: z.ZodString;
    operator: z.ZodEnum<["gt", "gte", "lt", "lte", "eq", "neq", "in", "not_in"]>;
    value: z.ZodUnknown;
}, "strip", z.ZodTypeAny, {
    value?: unknown;
    claim?: string;
    operator?: "in" | "not_in" | "gte" | "gt" | "lte" | "lt" | "eq" | "neq";
}, {
    value?: unknown;
    claim?: string;
    operator?: "in" | "not_in" | "gte" | "gt" | "lte" | "lt" | "eq" | "neq";
}>;
/**
 * Configuration for the ZK prover
 */
export interface ZKProverConfig {
    /** Default proof expiration in milliseconds */
    defaultProofTTL: number;
    /** Maximum proof generation timeout in milliseconds */
    proofGenerationTimeout: number;
    /** Whether to include metadata in proofs */
    includeMetadata: boolean;
    /** Custom circuit registry path */
    circuitRegistryPath?: string;
}
/**
 * Default ZK prover configuration
 */
export declare const DEFAULT_ZK_PROVER_CONFIG: ZKProverConfig;
export declare const zkProverConfigSchema: z.ZodObject<{
    defaultProofTTL: z.ZodDefault<z.ZodNumber>;
    proofGenerationTimeout: z.ZodDefault<z.ZodNumber>;
    includeMetadata: z.ZodDefault<z.ZodBoolean>;
    circuitRegistryPath: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    defaultProofTTL?: number;
    proofGenerationTimeout?: number;
    includeMetadata?: boolean;
    circuitRegistryPath?: string;
}, {
    defaultProofTTL?: number;
    proofGenerationTimeout?: number;
    includeMetadata?: boolean;
    circuitRegistryPath?: string;
}>;
/**
 * Configuration for the ZK verifier
 */
export interface ZKVerifierConfig {
    /** Enable verification result caching */
    enableCaching: boolean;
    /** Cache TTL in milliseconds */
    cacheTTL: number;
    /** Maximum cache size */
    maxCacheSize: number;
    /** Reject expired proofs */
    rejectExpiredProofs: boolean;
    /** Clock skew tolerance in milliseconds */
    clockSkewTolerance: number;
}
/**
 * Default ZK verifier configuration
 */
export declare const DEFAULT_ZK_VERIFIER_CONFIG: ZKVerifierConfig;
export declare const zkVerifierConfigSchema: z.ZodObject<{
    enableCaching: z.ZodDefault<z.ZodBoolean>;
    cacheTTL: z.ZodDefault<z.ZodNumber>;
    maxCacheSize: z.ZodDefault<z.ZodNumber>;
    rejectExpiredProofs: z.ZodDefault<z.ZodBoolean>;
    clockSkewTolerance: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    enableCaching?: boolean;
    cacheTTL?: number;
    maxCacheSize?: number;
    rejectExpiredProofs?: boolean;
    clockSkewTolerance?: number;
}, {
    enableCaching?: boolean;
    cacheTTL?: number;
    maxCacheSize?: number;
    rejectExpiredProofs?: boolean;
    clockSkewTolerance?: number;
}>;
/**
 * Compliance verification type
 */
export declare const ComplianceVerificationType: {
    /** Know Your Customer verification */
    readonly KYC: "kyc";
    /** Anti-Money Laundering screening */
    readonly AML: "aml";
    /** GDPR data subject verification */
    readonly GDPR: "gdpr";
    /** PCI-DSS cardholder verification */
    readonly PCI_DSS: "pci_dss";
    /** SOC 2 access verification */
    readonly SOC2: "soc2";
    /** Custom compliance check */
    readonly CUSTOM: "custom";
};
export type ComplianceVerificationType = (typeof ComplianceVerificationType)[keyof typeof ComplianceVerificationType];
export declare const complianceVerificationTypeSchema: z.ZodNativeEnum<{
    /** Know Your Customer verification */
    readonly KYC: "kyc";
    /** Anti-Money Laundering screening */
    readonly AML: "aml";
    /** GDPR data subject verification */
    readonly GDPR: "gdpr";
    /** PCI-DSS cardholder verification */
    readonly PCI_DSS: "pci_dss";
    /** SOC 2 access verification */
    readonly SOC2: "soc2";
    /** Custom compliance check */
    readonly CUSTOM: "custom";
}>;
/**
 * Compliance proof request
 */
export interface ComplianceProofRequest {
    /** Type of compliance verification */
    verificationType: ComplianceVerificationType;
    /** Required proofs */
    requiredProofs: string[];
    /** Optional additional constraints */
    constraints?: Record<string, unknown>;
    /** Request timestamp */
    requestedAt: Date;
    /** Request expiration */
    expiresAt?: Date;
    /** Nonce for replay protection */
    nonce: string;
}
export declare const complianceProofRequestSchema: z.ZodObject<{
    verificationType: z.ZodNativeEnum<{
        /** Know Your Customer verification */
        readonly KYC: "kyc";
        /** Anti-Money Laundering screening */
        readonly AML: "aml";
        /** GDPR data subject verification */
        readonly GDPR: "gdpr";
        /** PCI-DSS cardholder verification */
        readonly PCI_DSS: "pci_dss";
        /** SOC 2 access verification */
        readonly SOC2: "soc2";
        /** Custom compliance check */
        readonly CUSTOM: "custom";
    }>;
    requiredProofs: z.ZodArray<z.ZodString, "many">;
    constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    requestedAt: z.ZodDate;
    expiresAt: z.ZodOptional<z.ZodDate>;
    nonce: z.ZodString;
}, "strip", z.ZodTypeAny, {
    expiresAt?: Date;
    constraints?: Record<string, unknown>;
    nonce?: string;
    verificationType?: "custom" | "gdpr" | "kyc" | "aml" | "pci_dss" | "soc2";
    requiredProofs?: string[];
    requestedAt?: Date;
}, {
    expiresAt?: Date;
    constraints?: Record<string, unknown>;
    nonce?: string;
    verificationType?: "custom" | "gdpr" | "kyc" | "aml" | "pci_dss" | "soc2";
    requiredProofs?: string[];
    requestedAt?: Date;
}>;
/**
 * Compliance verification result
 */
export interface ComplianceVerificationResult {
    /** Verification type */
    verificationType: ComplianceVerificationType;
    /** Overall compliance status */
    compliant: boolean;
    /** Individual proof results */
    proofResults: VerificationResult[];
    /** Compliance timestamp */
    verifiedAt: Date;
    /** Validity period end */
    validUntil?: Date;
    /** Compliance attestation (for audit trail) */
    attestation?: string;
}
export declare const complianceVerificationResultSchema: z.ZodObject<{
    verificationType: z.ZodNativeEnum<{
        /** Know Your Customer verification */
        readonly KYC: "kyc";
        /** Anti-Money Laundering screening */
        readonly AML: "aml";
        /** GDPR data subject verification */
        readonly GDPR: "gdpr";
        /** PCI-DSS cardholder verification */
        readonly PCI_DSS: "pci_dss";
        /** SOC 2 access verification */
        readonly SOC2: "soc2";
        /** Custom compliance check */
        readonly CUSTOM: "custom";
    }>;
    compliant: z.ZodBoolean;
    proofResults: z.ZodArray<z.ZodObject<{
        valid: z.ZodBoolean;
        circuit: z.ZodString;
        verifiedAt: z.ZodDate;
        publicInputs: z.ZodArray<z.ZodString, "many">;
        error: z.ZodOptional<z.ZodString>;
        errorCode: z.ZodOptional<z.ZodString>;
        verificationTimeMs: z.ZodOptional<z.ZodNumber>;
        fromCache: z.ZodOptional<z.ZodBoolean>;
        cacheExpiresAt: z.ZodOptional<z.ZodDate>;
    }, "strip", z.ZodTypeAny, {
        valid?: boolean;
        error?: string;
        errorCode?: string;
        fromCache?: boolean;
        publicInputs?: string[];
        circuit?: string;
        verifiedAt?: Date;
        verificationTimeMs?: number;
        cacheExpiresAt?: Date;
    }, {
        valid?: boolean;
        error?: string;
        errorCode?: string;
        fromCache?: boolean;
        publicInputs?: string[];
        circuit?: string;
        verifiedAt?: Date;
        verificationTimeMs?: number;
        cacheExpiresAt?: Date;
    }>, "many">;
    verifiedAt: z.ZodDate;
    validUntil: z.ZodOptional<z.ZodDate>;
    attestation: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    attestation?: string;
    verifiedAt?: Date;
    verificationType?: "custom" | "gdpr" | "kyc" | "aml" | "pci_dss" | "soc2";
    compliant?: boolean;
    proofResults?: {
        valid?: boolean;
        error?: string;
        errorCode?: string;
        fromCache?: boolean;
        publicInputs?: string[];
        circuit?: string;
        verifiedAt?: Date;
        verificationTimeMs?: number;
        cacheExpiresAt?: Date;
    }[];
    validUntil?: Date;
}, {
    attestation?: string;
    verifiedAt?: Date;
    verificationType?: "custom" | "gdpr" | "kyc" | "aml" | "pci_dss" | "soc2";
    compliant?: boolean;
    proofResults?: {
        valid?: boolean;
        error?: string;
        errorCode?: string;
        fromCache?: boolean;
        publicInputs?: string[];
        circuit?: string;
        verifiedAt?: Date;
        verificationTimeMs?: number;
        cacheExpiresAt?: Date;
    }[];
    validUntil?: Date;
}>;
/**
 * Trusted setup ceremony parameters
 */
export interface TrustedSetupParams {
    /** Circuit identifier */
    circuitId: string;
    /** Number of participants required */
    participantsRequired: number;
    /** Contribution deadline */
    deadline: Date;
    /** Current ceremony phase */
    phase: 'contribution' | 'verification' | 'complete';
    /** Ceremony transcript hash */
    transcriptHash?: string;
}
export declare const trustedSetupParamsSchema: z.ZodObject<{
    circuitId: z.ZodString;
    participantsRequired: z.ZodNumber;
    deadline: z.ZodDate;
    phase: z.ZodEnum<["contribution", "verification", "complete"]>;
    transcriptHash: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    phase?: "complete" | "contribution" | "verification";
    circuitId?: string;
    participantsRequired?: number;
    deadline?: Date;
    transcriptHash?: string;
}, {
    phase?: "complete" | "contribution" | "verification";
    circuitId?: string;
    participantsRequired?: number;
    deadline?: Date;
    transcriptHash?: string;
}>;
/**
 * Proving key for generating proofs
 */
export interface ProvingKey {
    /** Key identifier */
    keyId: string;
    /** Circuit this key is for */
    circuitId: string;
    /** Serialized key data */
    keyData: Uint8Array;
    /** Key version */
    version: string;
    /** Key hash for integrity */
    hash: string;
    /** When the key was generated */
    generatedAt: Date;
}
export declare const provingKeySchema: z.ZodObject<{
    keyId: z.ZodString;
    circuitId: z.ZodString;
    keyData: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
    version: z.ZodString;
    hash: z.ZodString;
    generatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    version?: string;
    hash?: string;
    generatedAt?: Date;
    keyId?: string;
    circuitId?: string;
    keyData?: Uint8Array<ArrayBuffer>;
}, {
    version?: string;
    hash?: string;
    generatedAt?: Date;
    keyId?: string;
    circuitId?: string;
    keyData?: Uint8Array<ArrayBuffer>;
}>;
/**
 * Verification key for verifying proofs
 */
export interface VerificationKey {
    /** Key identifier */
    keyId: string;
    /** Circuit this key is for */
    circuitId: string;
    /** Serialized key data */
    keyData: Uint8Array;
    /** Key version */
    version: string;
    /** Key hash for integrity */
    hash: string;
    /** When the key was generated */
    generatedAt: Date;
}
export declare const verificationKeySchema: z.ZodObject<{
    keyId: z.ZodString;
    circuitId: z.ZodString;
    keyData: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
    version: z.ZodString;
    hash: z.ZodString;
    generatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    version?: string;
    hash?: string;
    generatedAt?: Date;
    keyId?: string;
    circuitId?: string;
    keyData?: Uint8Array<ArrayBuffer>;
}, {
    version?: string;
    hash?: string;
    generatedAt?: Date;
    keyId?: string;
    circuitId?: string;
    keyData?: Uint8Array<ArrayBuffer>;
}>;
/**
 * ZK proof policy condition for integration with policy engine
 */
export interface ZKProofPolicyCondition {
    /** Required circuit type */
    circuit: ZKCircuitType;
    /** Required public inputs pattern */
    publicInputsPattern?: Record<string, unknown>;
    /** Maximum proof age in milliseconds */
    maxProofAge?: number;
    /** Whether to allow cached verification results */
    allowCachedVerification?: boolean;
    /** Required compliance type if applicable */
    complianceType?: ComplianceVerificationType;
}
export declare const zkProofPolicyConditionSchema: z.ZodObject<{
    circuit: z.ZodNativeEnum<{
        /** Age verification without revealing date of birth */
        readonly AGE_VERIFICATION: "age_verification";
        /** Prove a value is within a range without revealing the value */
        readonly RANGE_PROOF: "range_proof";
        /** Prove membership in a set without revealing which element */
        readonly SET_MEMBERSHIP: "set_membership";
        /** Prove possession of a valid credential without revealing it */
        readonly CREDENTIAL_VERIFICATION: "credential_verification";
        /** Custom circuit for extensibility */
        readonly CUSTOM: "custom";
    }>;
    publicInputsPattern: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    maxProofAge: z.ZodOptional<z.ZodNumber>;
    allowCachedVerification: z.ZodOptional<z.ZodBoolean>;
    complianceType: z.ZodOptional<z.ZodNativeEnum<{
        /** Know Your Customer verification */
        readonly KYC: "kyc";
        /** Anti-Money Laundering screening */
        readonly AML: "aml";
        /** GDPR data subject verification */
        readonly GDPR: "gdpr";
        /** PCI-DSS cardholder verification */
        readonly PCI_DSS: "pci_dss";
        /** SOC 2 access verification */
        readonly SOC2: "soc2";
        /** Custom compliance check */
        readonly CUSTOM: "custom";
    }>>;
}, "strip", z.ZodTypeAny, {
    circuit?: "custom" | "age_verification" | "range_proof" | "set_membership" | "credential_verification";
    publicInputsPattern?: Record<string, unknown>;
    maxProofAge?: number;
    allowCachedVerification?: boolean;
    complianceType?: "custom" | "gdpr" | "kyc" | "aml" | "pci_dss" | "soc2";
}, {
    circuit?: "custom" | "age_verification" | "range_proof" | "set_membership" | "credential_verification";
    publicInputsPattern?: Record<string, unknown>;
    maxProofAge?: number;
    allowCachedVerification?: boolean;
    complianceType?: "custom" | "gdpr" | "kyc" | "aml" | "pci_dss" | "soc2";
}>;
/**
 * Session proof cache entry
 */
export interface SessionProofCache {
    /** Session identifier */
    sessionId: string;
    /** Cached proofs by circuit type */
    proofs: Map<string, ZKProof>;
    /** Cached verification results */
    verificationResults: Map<string, VerificationResult>;
    /** Session creation time */
    createdAt: Date;
    /** Session expiration */
    expiresAt: Date;
}
export declare const sessionProofCacheSchema: z.ZodObject<{
    sessionId: z.ZodString;
    proofs: z.ZodMap<z.ZodString, z.ZodObject<{
        proof: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
        publicInputs: z.ZodArray<z.ZodString, "many">;
        circuit: z.ZodString;
        timestamp: z.ZodDate;
        expiresAt: z.ZodOptional<z.ZodDate>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        version: z.ZodOptional<z.ZodString>;
        proofId: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        expiresAt?: Date;
        version?: string;
        timestamp?: Date;
        proof?: Uint8Array<ArrayBuffer>;
        metadata?: Record<string, unknown>;
        publicInputs?: string[];
        circuit?: string;
        proofId?: string;
    }, {
        expiresAt?: Date;
        version?: string;
        timestamp?: Date;
        proof?: Uint8Array<ArrayBuffer>;
        metadata?: Record<string, unknown>;
        publicInputs?: string[];
        circuit?: string;
        proofId?: string;
    }>>;
    verificationResults: z.ZodMap<z.ZodString, z.ZodObject<{
        valid: z.ZodBoolean;
        circuit: z.ZodString;
        verifiedAt: z.ZodDate;
        publicInputs: z.ZodArray<z.ZodString, "many">;
        error: z.ZodOptional<z.ZodString>;
        errorCode: z.ZodOptional<z.ZodString>;
        verificationTimeMs: z.ZodOptional<z.ZodNumber>;
        fromCache: z.ZodOptional<z.ZodBoolean>;
        cacheExpiresAt: z.ZodOptional<z.ZodDate>;
    }, "strip", z.ZodTypeAny, {
        valid?: boolean;
        error?: string;
        errorCode?: string;
        fromCache?: boolean;
        publicInputs?: string[];
        circuit?: string;
        verifiedAt?: Date;
        verificationTimeMs?: number;
        cacheExpiresAt?: Date;
    }, {
        valid?: boolean;
        error?: string;
        errorCode?: string;
        fromCache?: boolean;
        publicInputs?: string[];
        circuit?: string;
        verifiedAt?: Date;
        verificationTimeMs?: number;
        cacheExpiresAt?: Date;
    }>>;
    createdAt: z.ZodDate;
    expiresAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    createdAt?: Date;
    expiresAt?: Date;
    sessionId?: string;
    proofs?: Map<string, {
        expiresAt?: Date;
        version?: string;
        timestamp?: Date;
        proof?: Uint8Array<ArrayBuffer>;
        metadata?: Record<string, unknown>;
        publicInputs?: string[];
        circuit?: string;
        proofId?: string;
    }>;
    verificationResults?: Map<string, {
        valid?: boolean;
        error?: string;
        errorCode?: string;
        fromCache?: boolean;
        publicInputs?: string[];
        circuit?: string;
        verifiedAt?: Date;
        verificationTimeMs?: number;
        cacheExpiresAt?: Date;
    }>;
}, {
    createdAt?: Date;
    expiresAt?: Date;
    sessionId?: string;
    proofs?: Map<string, {
        expiresAt?: Date;
        version?: string;
        timestamp?: Date;
        proof?: Uint8Array<ArrayBuffer>;
        metadata?: Record<string, unknown>;
        publicInputs?: string[];
        circuit?: string;
        proofId?: string;
    }>;
    verificationResults?: Map<string, {
        valid?: boolean;
        error?: string;
        errorCode?: string;
        fromCache?: boolean;
        publicInputs?: string[];
        circuit?: string;
        verifiedAt?: Date;
        verificationTimeMs?: number;
        cacheExpiresAt?: Date;
    }>;
}>;
//# sourceMappingURL=types.d.ts.map