import { EventEmitter } from 'events';
import type { Storage } from '../storage.js';
import type { AddMemoryInput, CapabilityCaveats, CapabilityToken, CapabilityValidationInput, CapabilityValidationResult, ExportSubgraphInput, GenerateZkProofInput, GraphQueryInput, GraphQueryResult, IssueClaimInput, IssueCapabilityInput, LinkMemoryInput, MemoryQueryInput, MemoryQueryResult, PersonaClaim, PersonaEdge, PersonaNode, PersonaSyncDelta, PersonaVault, PortableSubgraph, RunRetentionSweepInput, RunRetentionSweepResult, SyncApplyResult, VerifyPersonaAccessLogInput, VerifyPersonaAccessLogResult, VerifyZkProofInput, UpdateMemoryInput, UpdatePreferenceInput, ZkProofBundle, ZkVerifyResult } from './types.js';
export interface PersonaEngineConfig {
    defaultVaultName?: string;
    encryptionKey?: string;
    shortTermWindow?: number;
    emaAlpha?: number;
    onnxModelPath?: string;
}
export declare class PersonaVaultEngine extends EventEmitter {
    private storage;
    private identityDid;
    private capabilityManager;
    private lifecycle;
    private embeddings;
    private zkp;
    private encryptionKey;
    private claimSigningSecret;
    private graphRankCache;
    constructor(storage: Storage, identityDid: string, config?: PersonaEngineConfig);
    createVault(input: {
        name: string;
        ownerDid?: string;
    }): Promise<PersonaVault>;
    addMemory(input: AddMemoryInput): Promise<PersonaNode>;
    updateMemory(nodeId: string, patch: UpdateMemoryInput): Promise<PersonaNode>;
    deleteMemory(nodeId: string, _reason?: string): Promise<void>;
    linkMemories(input: LinkMemoryInput): Promise<PersonaEdge>;
    queryMemories(input: MemoryQueryInput): Promise<MemoryQueryResult>;
    queryGraph(input: GraphQueryInput): Promise<GraphQueryResult>;
    updatePreference(input: UpdatePreferenceInput): Promise<PersonaNode>;
    verifyPersonaAccessLog(input: VerifyPersonaAccessLogInput): Promise<VerifyPersonaAccessLogResult>;
    runRetentionSweep(input?: RunRetentionSweepInput): Promise<RunRetentionSweepResult>;
    issueCapability(input: IssueCapabilityInput): Promise<CapabilityToken>;
    attenuateCapability(input: {
        tokenId: string;
        caveatsPatch: Partial<CapabilityCaveats>;
    }): Promise<CapabilityToken>;
    revokeCapability(tokenId: string, reason: string): Promise<void>;
    validateCapability(input: CapabilityValidationInput): CapabilityValidationResult;
    issueClaim(input: IssueClaimInput): Promise<PersonaClaim>;
    revokeClaim(claimId: string, _reason: string): Promise<void>;
    generateZkProof(input: GenerateZkProofInput): Promise<ZkProofBundle>;
    verifyZkProof(input: VerifyZkProofInput): Promise<ZkVerifyResult>;
    applySyncDelta(delta: PersonaSyncDelta): Promise<SyncApplyResult>;
    exportSubgraph(input: ExportSubgraphInput): Promise<PortableSubgraph>;
    getProfile(vaultId?: string): Promise<Record<string, unknown>>;
    listClaims(vaultId?: string, includeRevoked?: boolean): Promise<PersonaClaim[]>;
    getClaim(claimId: string): Promise<PersonaClaim | undefined>;
    listZkProofs(vaultId?: string): ZkProofBundle[];
    getZkProof(proofId: string): ZkProofBundle | undefined;
    listZkCircuits(): any[];
    buildSyncDelta(input: {
        vaultId: string;
        operations: Array<{
            type: 'node_upsert' | 'node_delete' | 'edge_upsert' | 'edge_delete' | 'capability_revoke' | 'capability_attenuate' | 'claim_upsert' | 'claim_revoke' | 'zkp_proof_upsert';
            payload: Record<string, unknown>;
        }>;
        cursor?: string;
        proofs?: ZkProofBundle[];
    }): PersonaSyncDelta;
    private resolveVaultId;
    private ensureDefaultVault;
    private bumpLifecycle;
    private indexEmbedding;
    private nextVectorRowId;
    private upsertLocalDomainDoc;
    private mergeCrdtDomainDoc;
    private recordMetric;
    private getOrBuildGraphRank;
    private inflateNode;
    private encrypt;
    private decrypt;
    private inflateClaim;
    private detectProofSystem;
}
export default PersonaVaultEngine;
//# sourceMappingURL=engine.d.ts.map