@spaik/mcp-server-roi/dist/services/predictive-analytics.d.ts

MCP server for AI ROI prediction and tracking with Monte Carlo simulations

import { z } from 'zod';
/**
 * Predictive Analytics Service
 *
 * Provides advanced predictive capabilities including success probability,
 * timeline predictions, risk correlation, and outcome modeling.
 */
export declare const SuccessProbabilitySchema: z.ZodObject<{
    overall: z.ZodNumber;
    factors: z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        weight: z.ZodNumber;
        score: z.ZodNumber;
        impact: z.ZodEnum<["positive", "negative"]>;
    }, "strip", z.ZodTypeAny, {
        name: string;
        impact: "positive" | "negative";
        weight: number;
        score: number;
    }, {
        name: string;
        impact: "positive" | "negative";
        weight: number;
        score: number;
    }>, "many">;
    confidence_interval: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
    key_drivers: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    overall: number;
    factors: {
        name: string;
        impact: "positive" | "negative";
        weight: number;
        score: number;
    }[];
    confidence_interval: [number, number];
    key_drivers: string[];
}, {
    overall: number;
    factors: {
        name: string;
        impact: "positive" | "negative";
        weight: number;
        score: number;
    }[];
    confidence_interval: [number, number];
    key_drivers: string[];
}>;
export declare const TimelinePredictionSchema: z.ZodObject<{
    expected_completion: z.ZodString;
    confidence: z.ZodNumber;
    milestones: z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        expected_date: z.ZodString;
        probability: z.ZodNumber;
        dependencies: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        name: string;
        dependencies: string[];
        probability: number;
        expected_date: string;
    }, {
        name: string;
        dependencies: string[];
        probability: number;
        expected_date: string;
    }>, "many">;
    critical_path: z.ZodArray<z.ZodString, "many">;
    buffer_recommendation: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    confidence: number;
    expected_completion: string;
    milestones: {
        name: string;
        dependencies: string[];
        probability: number;
        expected_date: string;
    }[];
    critical_path: string[];
    buffer_recommendation: number;
}, {
    confidence: number;
    expected_completion: string;
    milestones: {
        name: string;
        dependencies: string[];
        probability: number;
        expected_date: string;
    }[];
    critical_path: string[];
    buffer_recommendation: number;
}>;
export declare const RiskCorrelationSchema: z.ZodObject<{
    correlations: z.ZodArray<z.ZodObject<{
        factor1: z.ZodString;
        factor2: z.ZodString;
        correlation: z.ZodNumber;
        significance: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        correlation: number;
        factor1: string;
        factor2: string;
        significance: number;
    }, {
        correlation: number;
        factor1: string;
        factor2: string;
        significance: number;
    }>, "many">;
    risk_clusters: z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        factors: z.ZodArray<z.ZodString, "many">;
        combined_impact: z.ZodEnum<["low", "medium", "high", "critical"]>;
    }, "strip", z.ZodTypeAny, {
        name: string;
        factors: string[];
        combined_impact: "low" | "medium" | "high" | "critical";
    }, {
        name: string;
        factors: string[];
        combined_impact: "low" | "medium" | "high" | "critical";
    }>, "many">;
    mitigation_priorities: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    correlations: {
        correlation: number;
        factor1: string;
        factor2: string;
        significance: number;
    }[];
    risk_clusters: {
        name: string;
        factors: string[];
        combined_impact: "low" | "medium" | "high" | "critical";
    }[];
    mitigation_priorities: string[];
}, {
    correlations: {
        correlation: number;
        factor1: string;
        factor2: string;
        significance: number;
    }[];
    risk_clusters: {
        name: string;
        factors: string[];
        combined_impact: "low" | "medium" | "high" | "critical";
    }[];
    mitigation_priorities: string[];
}>;
export declare const OutcomePredictionSchema: z.ZodObject<{
    scenarios: z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        probability: z.ZodNumber;
        roi: z.ZodNumber;
        payback_months: z.ZodNumber;
        key_assumptions: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        name: string;
        roi: number;
        probability: number;
        payback_months: number;
        key_assumptions: string[];
    }, {
        name: string;
        roi: number;
        probability: number;
        payback_months: number;
        key_assumptions: string[];
    }>, "many">;
    most_likely: z.ZodString;
    variance_drivers: z.ZodArray<z.ZodObject<{
        factor: z.ZodString;
        sensitivity: z.ZodNumber;
        controllable: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        factor: string;
        sensitivity: number;
        controllable: boolean;
    }, {
        factor: string;
        sensitivity: number;
        controllable: boolean;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    scenarios: {
        name: string;
        roi: number;
        probability: number;
        payback_months: number;
        key_assumptions: string[];
    }[];
    most_likely: string;
    variance_drivers: {
        factor: string;
        sensitivity: number;
        controllable: boolean;
    }[];
}, {
    scenarios: {
        name: string;
        roi: number;
        probability: number;
        payback_months: number;
        key_assumptions: string[];
    }[];
    most_likely: string;
    variance_drivers: {
        factor: string;
        sensitivity: number;
        controllable: boolean;
    }[];
}>;
export type SuccessProbability = z.infer<typeof SuccessProbabilitySchema>;
export type TimelinePrediction = z.infer<typeof TimelinePredictionSchema>;
export type RiskCorrelation = z.infer<typeof RiskCorrelationSchema>;
export type OutcomePrediction = z.infer<typeof OutcomePredictionSchema>;
export declare class PredictiveAnalytics {
    private logger;
    private readonly SUCCESS_PATTERNS;
    /**
     * Predict success probability for ROI projects
     */
    predictProjectSuccess(projectData: any, historicalData?: any[]): Promise<SuccessProbability>;
    /**
     * Predict timeline with milestones and critical path
     */
    predictTimeline(projectData: any, useCases: any[]): Promise<TimelinePrediction>;
    /**
     * Analyze risk correlations and clusters
     */
    analyzeRiskCorrelations(risks: any[], projectContext: any): Promise<RiskCorrelation>;
    /**
     * Predict project outcomes with scenarios
     */
    predictOutcomes(projectData: any, marketConditions?: any): Promise<OutcomePrediction>;
    /**
     * Advanced ML-based pattern matching
     */
    matchHistoricalPatterns(currentProject: any, historicalProjects: any[]): Promise<{
        similar_projects: Array<{
            project_id: string;
            similarity_score: number;
            outcome: string;
            key_similarities: string[];
        }>;
        success_indicators: string[];
        warning_signs: string[];
    }>;
    private evaluateSuccessFactors;
    private calculateOverallSuccess;
    private calculateConfidenceInterval;
    private identifyKeyDrivers;
    private generateMilestones;
    private identifyCriticalPath;
    private calculateExpectedCompletion;
    private recommendBuffer;
    private calculateRiskCorrelations;
    private identifyRiskClusters;
    private prioritizeMitigations;
    private generateScenarios;
    private identifyMostLikelyScenario;
    private analyzeVarianceDrivers;
    private calculateProjectSimilarities;
    private extractSuccessIndicators;
    private extractWarningSigns;
    private calculateVariance;
}
export declare const predictiveAnalytics: PredictiveAnalytics;
//# sourceMappingURL=predictive-analytics.d.ts.map