/**
 * Trust Oracle Service
 * Main service for vendor trust scoring and third-party risk assessment
 */
import { TrustScore, RiskAssessment, VendorInfo, HealthEvent, Observable } from './types';
import { VendorRegistry } from './vendor-registry';
import { RiskScorer } from './risk-scorer';
import { DataSourceManager } from './data-sources';
import { ContinuousMonitoringService } from './continuous-monitoring';
import { AlertManager } from './alerts';
import { ReportingService } from './reporting';
export interface TrustOracle {
    getVendorTrustScore(vendorId: string): Promise<TrustScore>;
    getEntityTrustScore(entityId: string, entityType: string): Promise<TrustScore>;
    assessThirdPartyRisk(vendor: VendorInfo): Promise<RiskAssessment>;
    monitorVendorHealth(vendorId: string): Observable<HealthEvent>;
}
export interface TrustOracleConfig {
    vendorRegistry: VendorRegistry;
    riskScorer: RiskScorer;
    dataSourceManager: DataSourceManager;
    monitoringService: ContinuousMonitoringService;
    alertManager: AlertManager;
    reportingService: ReportingService;
    storage: TrustOracleStorage;
    cache: TrustScoreCache;
    options: TrustOracleOptions;
}
export interface TrustOracleOptions {
    cacheEnabled: boolean;
    cacheTTLSeconds: number;
    autoMonitoringEnabled: boolean;
    alertOnScoreDegradation: boolean;
    degradationThreshold: number;
    parallelDataFetching: boolean;
}
export interface TrustOracleStorage {
    saveTrustScore(vendorId: string, score: TrustScore): Promise<void>;
    getTrustScore(vendorId: string): Promise<TrustScore | null>;
    getTrustScoreHistory(vendorId: string, limit: number): Promise<TrustScore[]>;
    saveRiskAssessment(vendorId: string, assessment: RiskAssessment): Promise<void>;
    getRiskAssessment(vendorId: string): Promise<RiskAssessment | null>;
}
export interface TrustScoreCache {
    get(key: string): TrustScore | null;
    set(key: string, score: TrustScore, ttlSeconds: number): void;
    invalidate(key: string): void;
    clear(): void;
}
export declare class TrustOracleService implements TrustOracle {
    private readonly config;
    private readonly healthSubscribers;
    constructor(config: TrustOracleConfig);
    getVendorTrustScore(vendorId: string): Promise<TrustScore>;
    getEntityTrustScore(entityId: string, entityType: string): Promise<TrustScore>;
    getTrustScoreHistory(vendorId: string, limit?: number): Promise<TrustScore[]>;
    compareTrustScores(vendorIds: string[]): Promise<TrustScoreComparison>;
    assessThirdPartyRisk(vendor: VendorInfo): Promise<RiskAssessment>;
    assessMultipleVendors(vendorIds: string[]): Promise<Map<string, RiskAssessment>>;
    getConcentrationRisk(): Promise<ConcentrationRiskAnalysis>;
    monitorVendorHealth(vendorId: string): Observable<HealthEvent>;
    startVendorMonitoring(vendorId: string): Promise<void>;
    stopVendorMonitoring(vendorId: string): Promise<void>;
    getMonitoringStatus(vendorId: string): Promise<MonitoringStatus>;
    private gatherScoreInput;
    private gatherAssessmentInput;
    private gatherSecurityControls;
    private extractSLAPerformance;
    private extractDataProcessingTerms;
    private extractSecurityRequirements;
    private checkAuditRights;
    private isScoreValid;
    private isAssessmentValid;
    private checkScoreDegradation;
    private createAssessmentAlerts;
    private findParentVendor;
    private assessSubsidiaryTrust;
    private assessSubcontractorTrust;
    private ensureMonitoringStarted;
    private calculateHealthScore;
    private getMonitoringFrequency;
    private getMonitoringChecks;
    private getAlertThresholds;
    private identifyConcentrationRisks;
}
interface TrustScoreComparison {
    vendors: Array<{
        vendorId: string;
        score: TrustScore;
    }>;
    ranking: string[];
    averageScore: number;
    highestScore: {
        vendorId: string;
        score: TrustScore;
    };
    lowestScore: {
        vendorId: string;
        score: TrustScore;
    };
    comparisonDate: Date;
}
interface ConcentrationRiskAnalysis {
    totalVendors: number;
    categoryConcentration: Record<string, number>;
    tierConcentration: Record<string, number>;
    riskConcentration: Record<string, number>;
    topConcentrationRisks: string[];
    analysisDate: Date;
}
interface MonitoringStatus {
    vendorId: string;
    isMonitored: boolean;
    lastCheck: Date | null;
    healthScore: number | null;
    activeAlerts: number;
}
export declare class TrustOracleError extends Error {
    readonly code: string;
    constructor(code: string, message: string);
}
export declare function createTrustOracle(config: TrustOracleConfig): TrustOracleService;
export declare function getDefaultTrustOracleOptions(): TrustOracleOptions;
export {};
//# sourceMappingURL=oracle.d.ts.map