anon-identity/dist/agent/activity/activity-archival-service.d.ts

Decentralized identity framework with DIDs, Verifiable Credentials, and privacy-preserving selective disclosure

import { AgentActivity, ActivityQuery } from './types';
import { ActivitySearchService } from './activity-search-service';
import { ActivityExporter, ExportFormat, AuditProof } from './activity-exporter';
import { ActivityIndex } from './activity-index';
import { IPFSActivityStorage } from './ipfs-activity-storage';
export interface ArchivalPolicy {
    id: string;
    name: string;
    description: string;
    retentionPeriod: number;
    archiveAfter: number;
    autoDelete: boolean;
    compressionEnabled: boolean;
    encryptionRequired: boolean;
    complianceStandard?: 'gdpr' | 'hipaa' | 'sox' | 'iso27001';
    triggers: ArchivalTrigger[];
}
export interface ArchivalTrigger {
    type: 'time' | 'size' | 'count' | 'compliance';
    condition: any;
    action: 'archive' | 'delete' | 'export' | 'notify';
}
export interface ArchivalRule {
    agentDID?: string;
    parentDID?: string;
    serviceDID?: string;
    activityTypes?: string[];
    policy: ArchivalPolicy;
    priority: number;
    active: boolean;
}
export interface ArchivalRecord {
    id: string;
    originalActivityIds: string[];
    archiveDate: Date;
    policy: string;
    location: string;
    checksum: string;
    proof: AuditProof;
    metadata: {
        totalActivities: number;
        dateRange: {
            start: Date;
            end: Date;
        };
        format: ExportFormat;
        compressed: boolean;
        encrypted: boolean;
    };
}
export interface DataRetentionConfig {
    defaultRetentionDays: number;
    maxRetentionDays: number;
    complianceMode: boolean;
    auditLogging: boolean;
    autoArchival: boolean;
    notificationEnabled: boolean;
    warningDays: number;
}
export interface GDPRComplianceInfo {
    dataSubject: string;
    processingBasis: 'consent' | 'contract' | 'legal_obligation' | 'vital_interests' | 'public_task' | 'legitimate_interests';
    categories: string[];
    recipients: string[];
    retentionPeriod: string;
    rightsInformed: boolean;
    consentWithdrawable: boolean;
}
export declare class ActivityArchivalService {
    private searchService;
    private exporter;
    private index;
    private ipfsStorage?;
    private config;
    private policies;
    private rules;
    private archivalRecords;
    private gdprRecords;
    constructor(searchService: ActivitySearchService, exporter: ActivityExporter, index: ActivityIndex, ipfsStorage?: IPFSActivityStorage, config?: Partial<DataRetentionConfig>);
    /**
     * Add archival policy
     */
    addPolicy(policy: ArchivalPolicy): void;
    /**
     * Add archival rule
     */
    addRule(rule: ArchivalRule): void;
    /**
     * Archive activities based on criteria
     */
    archiveActivities(query: ActivityQuery, policyId: string, options?: {
        deleteOriginals?: boolean;
        createProof?: boolean;
        encryptionKey?: Uint8Array;
    }): Promise<ArchivalRecord>;
    /**
     * Restore activities from archive
     */
    restoreActivities(archivalRecordId: string): Promise<AgentActivity[]>;
    /**
     * Delete expired activities based on retention policies
     */
    deleteExpiredActivities(): Promise<{
        deleted: number;
        archived: number;
        warned: number;
    }>;
    /**
     * Register GDPR compliance information
     */
    registerGDPRCompliance(parentDID: string, info: GDPRComplianceInfo): void;
    /**
     * Handle GDPR data subject request (right to be forgotten)
     */
    handleGDPRDataDeletion(parentDID: string): Promise<{
        activitiesDeleted: number;
        archivesDeleted: number;
    }>;
    /**
     * Generate data retention report
     */
    generateRetentionReport(): Promise<{
        totalActivities: number;
        activitiesByAge: Record<string, number>;
        archivalRecords: number;
        upcomingExpirations: number;
        complianceStatus: string;
    }>;
    private initializeDefaultPolicies;
    private startArchivalScheduler;
    private deleteActivitiesFromIndex;
    private storeInIPFS;
    private retrieveFromIPFS;
    private deleteArchive;
    private sendExpirationWarning;
    private generateId;
}
//# sourceMappingURL=activity-archival-service.d.ts.map