@vorionsys/platform-core 0.1.0

package/dist/security/zkp/types.d.ts

@@ -0,0 +1,1192 @@
+/**
+ * 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, {
+    version?: string;
+    name?: string;
+    description?: string;
+    type?: "custom" | "age_verification" | "range_proof" | "set_membership" | "credential_verification";
+    registeredAt?: Date;
+    publicInputs?: string[];
+    privateInputs?: string[];
+    verificationKeyHash?: string;
+}, {
+    version?: string;
+    name?: string;
+    description?: string;
+    type?: "custom" | "age_verification" | "range_proof" | "set_membership" | "credential_verification";
+    registeredAt?: Date;
+    publicInputs?: string[];
+    privateInputs?: string[];
+    verificationKeyHash?: string;
+}>;
+/**
+ * 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, {
+    version?: string;
+    metadata?: Record<string, unknown>;
+    proof?: Uint8Array<ArrayBuffer>;
+    expiresAt?: Date;
+    timestamp?: Date;
+    proofId?: string;
+    circuit?: string;
+    publicInputs?: string[];
+}, {
+    version?: string;
+    metadata?: Record<string, unknown>;
+    proof?: Uint8Array<ArrayBuffer>;
+    expiresAt?: Date;
+    timestamp?: Date;
+    proofId?: string;
+    circuit?: string;
+    publicInputs?: 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, {
+    version?: string;
+    metadata?: Record<string, unknown>;
+    proof?: string;
+    expiresAt?: string;
+    timestamp?: string;
+    proofId?: string;
+    circuit?: string;
+    publicInputs?: string[];
+}, {
+    version?: string;
+    metadata?: Record<string, unknown>;
+    proof?: string;
+    expiresAt?: string;
+    timestamp?: string;
+    proofId?: string;
+    circuit?: string;
+    publicInputs?: 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, {
+    error?: string;
+    valid?: boolean;
+    errorCode?: string;
+    verifiedAt?: Date;
+    fromCache?: boolean;
+    circuit?: string;
+    publicInputs?: string[];
+    verificationTimeMs?: number;
+    cacheExpiresAt?: Date;
+}, {
+    error?: string;
+    valid?: boolean;
+    errorCode?: string;
+    verifiedAt?: Date;
+    fromCache?: boolean;
+    circuit?: string;
+    publicInputs?: string[];
+    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, {
+        error?: string;
+        valid?: boolean;
+        errorCode?: string;
+        verifiedAt?: Date;
+        fromCache?: boolean;
+        circuit?: string;
+        publicInputs?: string[];
+        verificationTimeMs?: number;
+        cacheExpiresAt?: Date;
+    }, {
+        error?: string;
+        valid?: boolean;
+        errorCode?: string;
+        verifiedAt?: Date;
+        fromCache?: boolean;
+        circuit?: string;
+        publicInputs?: string[];
+        verificationTimeMs?: number;
+        cacheExpiresAt?: Date;
+    }>, "many">;
+    totalTimeMs: z.ZodNumber;
+    completedAt: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    results?: {
+        error?: string;
+        valid?: boolean;
+        errorCode?: string;
+        verifiedAt?: Date;
+        fromCache?: boolean;
+        circuit?: string;
+        publicInputs?: string[];
+        verificationTimeMs?: number;
+        cacheExpiresAt?: Date;
+    }[];
+    totalProofs?: number;
+    completedAt?: Date;
+    allValid?: boolean;
+    validProofs?: number;
+    totalTimeMs?: number;
+}, {
+    results?: {
+        error?: string;
+        valid?: boolean;
+        errorCode?: string;
+        verifiedAt?: Date;
+        fromCache?: boolean;
+        circuit?: string;
+        publicInputs?: string[];
+        verificationTimeMs?: number;
+        cacheExpiresAt?: Date;
+    }[];
+    totalProofs?: number;
+    completedAt?: Date;
+    allValid?: boolean;
+    validProofs?: number;
+    totalTimeMs?: number;
+}>;
+/**
+ * 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;
+    parameters?: Record<string, unknown>;
+    scheme?: "hash" | "pedersen" | "merkle" | "accumulator";
+    blindingFactor?: string;
+}, {
+    value?: string;
+    createdAt?: Date;
+    parameters?: Record<string, unknown>;
+    scheme?: "hash" | "pedersen" | "merkle" | "accumulator";
+    blindingFactor?: string;
+}>;
+/**
+ * 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, {
+    root?: string;
+    leafIndex?: number;
+    leaf?: string;
+    siblings?: string[];
+    pathIndices?: number[];
+}, {
+    root?: string;
+    leafIndex?: number;
+    leaf?: string;
+    siblings?: string[];
+    pathIndices?: 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;
+    signature?: string;
+    issuedAt?: Date;
+    subject?: string;
+    claims?: Record<string, unknown>;
+    revocationCommitment?: string;
+}, {
+    id?: string;
+    type?: string;
+    expiresAt?: Date;
+    issuer?: string;
+    signature?: string;
+    issuedAt?: Date;
+    subject?: string;
+    claims?: Record<string, unknown>;
+    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, {
+        operator?: "in" | "not_in" | "eq" | "gt" | "lt" | "gte" | "lte" | "neq";
+        value?: unknown;
+        claim?: string;
+    }, {
+        operator?: "in" | "not_in" | "eq" | "gt" | "lt" | "gte" | "lte" | "neq";
+        value?: unknown;
+        claim?: string;
+    }>>, "many">;
+}, "strip", z.ZodTypeAny, {
+    proveExistence?: string[];
+    reveal?: string[];
+    predicates?: {
+        operator?: "in" | "not_in" | "eq" | "gt" | "lt" | "gte" | "lte" | "neq";
+        value?: unknown;
+        claim?: string;
+    }[];
+}, {
+    proveExistence?: string[];
+    reveal?: string[];
+    predicates?: {
+        operator?: "in" | "not_in" | "eq" | "gt" | "lt" | "gte" | "lte" | "neq";
+        value?: unknown;
+        claim?: string;
+    }[];
+}>;
+/**
+ * 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, {
+    operator?: "in" | "not_in" | "eq" | "gt" | "lt" | "gte" | "lte" | "neq";
+    value?: unknown;
+    claim?: string;
+}, {
+    operator?: "in" | "not_in" | "eq" | "gt" | "lt" | "gte" | "lte" | "neq";
+    value?: unknown;
+    claim?: string;
+}>;
+/**
+ * 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, {
+    clockSkewTolerance?: number;
+    maxCacheSize?: number;
+    enableCaching?: boolean;
+    cacheTTL?: number;
+    rejectExpiredProofs?: boolean;
+}, {
+    clockSkewTolerance?: number;
+    maxCacheSize?: number;
+    enableCaching?: boolean;
+    cacheTTL?: number;
+    rejectExpiredProofs?: boolean;
+}>;
+/**
+ * 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>;
+    requestedAt?: Date;
+    nonce?: string;
+    verificationType?: "custom" | "gdpr" | "soc2" | "kyc" | "aml" | "pci_dss";
+    requiredProofs?: string[];
+}, {
+    expiresAt?: Date;
+    constraints?: Record<string, unknown>;
+    requestedAt?: Date;
+    nonce?: string;
+    verificationType?: "custom" | "gdpr" | "soc2" | "kyc" | "aml" | "pci_dss";
+    requiredProofs?: string[];
+}>;
+/**
+ * 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, {
+        error?: string;
+        valid?: boolean;
+        errorCode?: string;
+        verifiedAt?: Date;
+        fromCache?: boolean;
+        circuit?: string;
+        publicInputs?: string[];
+        verificationTimeMs?: number;
+        cacheExpiresAt?: Date;
+    }, {
+        error?: string;
+        valid?: boolean;
+        errorCode?: string;
+        verifiedAt?: Date;
+        fromCache?: boolean;
+        circuit?: string;
+        publicInputs?: string[];
+        verificationTimeMs?: number;
+        cacheExpiresAt?: Date;
+    }>, "many">;
+    verifiedAt: z.ZodDate;
+    validUntil: z.ZodOptional<z.ZodDate>;
+    attestation: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    compliant?: boolean;
+    verifiedAt?: Date;
+    validUntil?: Date;
+    attestation?: string;
+    verificationType?: "custom" | "gdpr" | "soc2" | "kyc" | "aml" | "pci_dss";
+    proofResults?: {
+        error?: string;
+        valid?: boolean;
+        errorCode?: string;
+        verifiedAt?: Date;
+        fromCache?: boolean;
+        circuit?: string;
+        publicInputs?: string[];
+        verificationTimeMs?: number;
+        cacheExpiresAt?: Date;
+    }[];
+}, {
+    compliant?: boolean;
+    verifiedAt?: Date;
+    validUntil?: Date;
+    attestation?: string;
+    verificationType?: "custom" | "gdpr" | "soc2" | "kyc" | "aml" | "pci_dss";
+    proofResults?: {
+        error?: string;
+        valid?: boolean;
+        errorCode?: string;
+        verifiedAt?: Date;
+        fromCache?: boolean;
+        circuit?: string;
+        publicInputs?: string[];
+        verificationTimeMs?: number;
+        cacheExpiresAt?: 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";
+    deadline?: Date;
+    circuitId?: string;
+    participantsRequired?: number;
+    transcriptHash?: string;
+}, {
+    phase?: "complete" | "contribution" | "verification";
+    deadline?: Date;
+    circuitId?: string;
+    participantsRequired?: number;
+    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;
+    keyId?: string;
+    generatedAt?: Date;
+    circuitId?: string;
+    keyData?: Uint8Array<ArrayBuffer>;
+}, {
+    version?: string;
+    hash?: string;
+    keyId?: string;
+    generatedAt?: Date;
+    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;
+    keyId?: string;
+    generatedAt?: Date;
+    circuitId?: string;
+    keyData?: Uint8Array<ArrayBuffer>;
+}, {
+    version?: string;
+    hash?: string;
+    keyId?: string;
+    generatedAt?: Date;
+    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, {
+    maxProofAge?: number;
+    circuit?: "custom" | "age_verification" | "range_proof" | "set_membership" | "credential_verification";
+    publicInputsPattern?: Record<string, unknown>;
+    allowCachedVerification?: boolean;
+    complianceType?: "custom" | "gdpr" | "soc2" | "kyc" | "aml" | "pci_dss";
+}, {
+    maxProofAge?: number;
+    circuit?: "custom" | "age_verification" | "range_proof" | "set_membership" | "credential_verification";
+    publicInputsPattern?: Record<string, unknown>;
+    allowCachedVerification?: boolean;
+    complianceType?: "custom" | "gdpr" | "soc2" | "kyc" | "aml" | "pci_dss";
+}>;
+/**
+ * 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, {
+        version?: string;
+        metadata?: Record<string, unknown>;
+        proof?: Uint8Array<ArrayBuffer>;
+        expiresAt?: Date;
+        timestamp?: Date;
+        proofId?: string;
+        circuit?: string;
+        publicInputs?: string[];
+    }, {
+        version?: string;
+        metadata?: Record<string, unknown>;
+        proof?: Uint8Array<ArrayBuffer>;
+        expiresAt?: Date;
+        timestamp?: Date;
+        proofId?: string;
+        circuit?: string;
+        publicInputs?: 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, {
+        error?: string;
+        valid?: boolean;
+        errorCode?: string;
+        verifiedAt?: Date;
+        fromCache?: boolean;
+        circuit?: string;
+        publicInputs?: string[];
+        verificationTimeMs?: number;
+        cacheExpiresAt?: Date;
+    }, {
+        error?: string;
+        valid?: boolean;
+        errorCode?: string;
+        verifiedAt?: Date;
+        fromCache?: boolean;
+        circuit?: string;
+        publicInputs?: string[];
+        verificationTimeMs?: number;
+        cacheExpiresAt?: Date;
+    }>>;
+    createdAt: z.ZodDate;
+    expiresAt: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    sessionId?: string;
+    createdAt?: Date;
+    expiresAt?: Date;
+    proofs?: Map<string, {
+        version?: string;
+        metadata?: Record<string, unknown>;
+        proof?: Uint8Array<ArrayBuffer>;
+        expiresAt?: Date;
+        timestamp?: Date;
+        proofId?: string;
+        circuit?: string;
+        publicInputs?: string[];
+    }>;
+    verificationResults?: Map<string, {
+        error?: string;
+        valid?: boolean;
+        errorCode?: string;
+        verifiedAt?: Date;
+        fromCache?: boolean;
+        circuit?: string;
+        publicInputs?: string[];
+        verificationTimeMs?: number;
+        cacheExpiresAt?: Date;
+    }>;
+}, {
+    sessionId?: string;
+    createdAt?: Date;
+    expiresAt?: Date;
+    proofs?: Map<string, {
+        version?: string;
+        metadata?: Record<string, unknown>;
+        proof?: Uint8Array<ArrayBuffer>;
+        expiresAt?: Date;
+        timestamp?: Date;
+        proofId?: string;
+        circuit?: string;
+        publicInputs?: string[];
+    }>;
+    verificationResults?: Map<string, {
+        error?: string;
+        valid?: boolean;
+        errorCode?: string;
+        verifiedAt?: Date;
+        fromCache?: boolean;
+        circuit?: string;
+        publicInputs?: string[];
+        verificationTimeMs?: number;
+        cacheExpiresAt?: Date;
+    }>;
+}>;
+//# sourceMappingURL=types.d.ts.map