@spaik/mcp-server-roi/dist/services/recommendation-engine.d.ts

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

import { z } from 'zod';
/**
 * Recommendation Engine Service
 *
 * Generates personalized, actionable recommendations using ML-driven insights,
 * historical patterns, and contextual understanding.
 */
export declare const RecommendationSchema: z.ZodObject<{
    id: z.ZodString;
    type: z.ZodEnum<["strategic", "tactical", "operational", "risk_mitigation", "opportunity"]>;
    priority: z.ZodEnum<["critical", "high", "medium", "low"]>;
    title: z.ZodString;
    description: z.ZodString;
    rationale: z.ZodString;
    expected_impact: z.ZodObject<{
        metric: z.ZodString;
        change: z.ZodString;
        confidence: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        confidence: number;
        metric: string;
        change: string;
    }, {
        confidence: number;
        metric: string;
        change: string;
    }>;
    implementation: z.ZodObject<{
        complexity: z.ZodEnum<["low", "medium", "high"]>;
        timeline: z.ZodString;
        prerequisites: z.ZodArray<z.ZodString, "many">;
        resources_required: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        timeline: string;
        prerequisites: string[];
        complexity: "low" | "medium" | "high";
        resources_required: string[];
    }, {
        timeline: string;
        prerequisites: string[];
        complexity: "low" | "medium" | "high";
        resources_required: string[];
    }>;
    alternatives: z.ZodOptional<z.ZodArray<z.ZodObject<{
        title: z.ZodString;
        tradeoff: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        title: string;
        tradeoff: string;
    }, {
        title: string;
        tradeoff: string;
    }>, "many">>;
    success_criteria: z.ZodArray<z.ZodString, "many">;
    related_insights: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    id: string;
    type: "strategic" | "tactical" | "operational" | "risk_mitigation" | "opportunity";
    description: string;
    implementation: {
        timeline: string;
        prerequisites: string[];
        complexity: "low" | "medium" | "high";
        resources_required: string[];
    };
    title: string;
    success_criteria: string[];
    priority: "low" | "medium" | "high" | "critical";
    rationale: string;
    expected_impact: {
        confidence: number;
        metric: string;
        change: string;
    };
    alternatives?: {
        title: string;
        tradeoff: string;
    }[] | undefined;
    related_insights?: string[] | undefined;
}, {
    id: string;
    type: "strategic" | "tactical" | "operational" | "risk_mitigation" | "opportunity";
    description: string;
    implementation: {
        timeline: string;
        prerequisites: string[];
        complexity: "low" | "medium" | "high";
        resources_required: string[];
    };
    title: string;
    success_criteria: string[];
    priority: "low" | "medium" | "high" | "critical";
    rationale: string;
    expected_impact: {
        confidence: number;
        metric: string;
        change: string;
    };
    alternatives?: {
        title: string;
        tradeoff: string;
    }[] | undefined;
    related_insights?: string[] | undefined;
}>;
export declare const PersonalizedRecommendationsSchema: z.ZodObject<{
    recommendations: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        type: z.ZodEnum<["strategic", "tactical", "operational", "risk_mitigation", "opportunity"]>;
        priority: z.ZodEnum<["critical", "high", "medium", "low"]>;
        title: z.ZodString;
        description: z.ZodString;
        rationale: z.ZodString;
        expected_impact: z.ZodObject<{
            metric: z.ZodString;
            change: z.ZodString;
            confidence: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            confidence: number;
            metric: string;
            change: string;
        }, {
            confidence: number;
            metric: string;
            change: string;
        }>;
        implementation: z.ZodObject<{
            complexity: z.ZodEnum<["low", "medium", "high"]>;
            timeline: z.ZodString;
            prerequisites: z.ZodArray<z.ZodString, "many">;
            resources_required: z.ZodArray<z.ZodString, "many">;
        }, "strip", z.ZodTypeAny, {
            timeline: string;
            prerequisites: string[];
            complexity: "low" | "medium" | "high";
            resources_required: string[];
        }, {
            timeline: string;
            prerequisites: string[];
            complexity: "low" | "medium" | "high";
            resources_required: string[];
        }>;
        alternatives: z.ZodOptional<z.ZodArray<z.ZodObject<{
            title: z.ZodString;
            tradeoff: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            title: string;
            tradeoff: string;
        }, {
            title: string;
            tradeoff: string;
        }>, "many">>;
        success_criteria: z.ZodArray<z.ZodString, "many">;
        related_insights: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        id: string;
        type: "strategic" | "tactical" | "operational" | "risk_mitigation" | "opportunity";
        description: string;
        implementation: {
            timeline: string;
            prerequisites: string[];
            complexity: "low" | "medium" | "high";
            resources_required: string[];
        };
        title: string;
        success_criteria: string[];
        priority: "low" | "medium" | "high" | "critical";
        rationale: string;
        expected_impact: {
            confidence: number;
            metric: string;
            change: string;
        };
        alternatives?: {
            title: string;
            tradeoff: string;
        }[] | undefined;
        related_insights?: string[] | undefined;
    }, {
        id: string;
        type: "strategic" | "tactical" | "operational" | "risk_mitigation" | "opportunity";
        description: string;
        implementation: {
            timeline: string;
            prerequisites: string[];
            complexity: "low" | "medium" | "high";
            resources_required: string[];
        };
        title: string;
        success_criteria: string[];
        priority: "low" | "medium" | "high" | "critical";
        rationale: string;
        expected_impact: {
            confidence: number;
            metric: string;
            change: string;
        };
        alternatives?: {
            title: string;
            tradeoff: string;
        }[] | undefined;
        related_insights?: string[] | undefined;
    }>, "many">;
    strategy_narrative: z.ZodString;
    decision_framework: z.ZodObject<{
        criteria: z.ZodArray<z.ZodString, "many">;
        weights: z.ZodRecord<z.ZodString, z.ZodNumber>;
        scoring_method: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        criteria: string[];
        weights: Record<string, number>;
        scoring_method: string;
    }, {
        criteria: string[];
        weights: Record<string, number>;
        scoring_method: string;
    }>;
    implementation_roadmap: z.ZodArray<z.ZodObject<{
        phase: z.ZodString;
        duration: z.ZodString;
        key_activities: z.ZodArray<z.ZodString, "many">;
        milestones: z.ZodArray<z.ZodString, "many">;
        dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        phase: string;
        duration: string;
        key_activities: string[];
        milestones: string[];
        dependencies?: string[] | undefined;
    }, {
        phase: string;
        duration: string;
        key_activities: string[];
        milestones: string[];
        dependencies?: string[] | undefined;
    }>, "many">;
    risk_considerations: z.ZodArray<z.ZodObject<{
        risk: z.ZodString;
        mitigation: z.ZodString;
        contingency: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        mitigation: string;
        risk: string;
        contingency?: string | undefined;
    }, {
        mitigation: string;
        risk: string;
        contingency?: string | undefined;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    recommendations: {
        id: string;
        type: "strategic" | "tactical" | "operational" | "risk_mitigation" | "opportunity";
        description: string;
        implementation: {
            timeline: string;
            prerequisites: string[];
            complexity: "low" | "medium" | "high";
            resources_required: string[];
        };
        title: string;
        success_criteria: string[];
        priority: "low" | "medium" | "high" | "critical";
        rationale: string;
        expected_impact: {
            confidence: number;
            metric: string;
            change: string;
        };
        alternatives?: {
            title: string;
            tradeoff: string;
        }[] | undefined;
        related_insights?: string[] | undefined;
    }[];
    strategy_narrative: string;
    decision_framework: {
        criteria: string[];
        weights: Record<string, number>;
        scoring_method: string;
    };
    implementation_roadmap: {
        phase: string;
        duration: string;
        key_activities: string[];
        milestones: string[];
        dependencies?: string[] | undefined;
    }[];
    risk_considerations: {
        mitigation: string;
        risk: string;
        contingency?: string | undefined;
    }[];
}, {
    recommendations: {
        id: string;
        type: "strategic" | "tactical" | "operational" | "risk_mitigation" | "opportunity";
        description: string;
        implementation: {
            timeline: string;
            prerequisites: string[];
            complexity: "low" | "medium" | "high";
            resources_required: string[];
        };
        title: string;
        success_criteria: string[];
        priority: "low" | "medium" | "high" | "critical";
        rationale: string;
        expected_impact: {
            confidence: number;
            metric: string;
            change: string;
        };
        alternatives?: {
            title: string;
            tradeoff: string;
        }[] | undefined;
        related_insights?: string[] | undefined;
    }[];
    strategy_narrative: string;
    decision_framework: {
        criteria: string[];
        weights: Record<string, number>;
        scoring_method: string;
    };
    implementation_roadmap: {
        phase: string;
        duration: string;
        key_activities: string[];
        milestones: string[];
        dependencies?: string[] | undefined;
    }[];
    risk_considerations: {
        mitigation: string;
        risk: string;
        contingency?: string | undefined;
    }[];
}>;
export declare const NextBestActionSchema: z.ZodObject<{
    action: z.ZodString;
    reasoning: z.ZodString;
    expected_outcome: z.ZodString;
    confidence: z.ZodNumber;
    prerequisites_met: z.ZodBoolean;
    missing_prerequisites: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    estimated_effort: z.ZodObject<{
        hours: z.ZodNumber;
        complexity: z.ZodEnum<["trivial", "simple", "moderate", "complex", "very_complex"]>;
    }, "strip", z.ZodTypeAny, {
        complexity: "trivial" | "simple" | "moderate" | "complex" | "very_complex";
        hours: number;
    }, {
        complexity: "trivial" | "simple" | "moderate" | "complex" | "very_complex";
        hours: number;
    }>;
    tools_needed: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    confidence: number;
    action: string;
    reasoning: string;
    expected_outcome: string;
    prerequisites_met: boolean;
    estimated_effort: {
        complexity: "trivial" | "simple" | "moderate" | "complex" | "very_complex";
        hours: number;
    };
    tools_needed: string[];
    missing_prerequisites?: string[] | undefined;
}, {
    confidence: number;
    action: string;
    reasoning: string;
    expected_outcome: string;
    prerequisites_met: boolean;
    estimated_effort: {
        complexity: "trivial" | "simple" | "moderate" | "complex" | "very_complex";
        hours: number;
    };
    tools_needed: string[];
    missing_prerequisites?: string[] | undefined;
}>;
export type Recommendation = z.infer<typeof RecommendationSchema>;
export type PersonalizedRecommendations = z.infer<typeof PersonalizedRecommendationsSchema>;
export type NextBestAction = z.infer<typeof NextBestActionSchema>;
export declare class RecommendationEngine {
    private logger;
    private readonly RECOMMENDATION_PATTERNS;
    /**
     * Generate personalized recommendations for a project
     */
    generateRecommendations(projectData: any, context?: any): Promise<PersonalizedRecommendations>;
    /**
     * Determine next best action based on current state
     */
    getNextBestAction(currentState: any, availableActions: string[], context?: any): Promise<NextBestAction>;
    /**
     * Generate industry-specific recommendations
     */
    getIndustryRecommendations(industry: string, projectData: any): Promise<Recommendation[]>;
    /**
     * Generate recommendations for project portfolio
     */
    getPortfolioRecommendations(projects: any[], constraints?: {
        budget?: number;
        timeline?: number;
        resources?: any;
    }): Promise<{
        portfolio_strategy: string;
        project_priorities: Array<{
            project_id: string;
            priority: number;
            rationale: string;
        }>;
        synergy_opportunities: Array<{
            projects: string[];
            synergy_type: string;
            value_add: string;
        }>;
        resource_optimization: Recommendation[];
    }>;
    private createRecommendations;
    private extractMetrics;
    private calculateComplexityScore;
    private instantiateRecommendation;
    private fillTemplate;
    private generateRationale;
    private createOpportunityRecommendation;
    private createRiskRecommendation;
    private createSuccessImprovementRecommendation;
    private generateStrategyNarrative;
    private createDecisionFramework;
    private generateImplementationRoadmap;
    private identifyRiskConsiderations;
    private generateMitigation;
    private generateContingency;
    private scoreAction;
    private generateActionReasoning;
    private predictActionOutcome;
    private checkPrerequisites;
    private checkPrerequisite;
    private estimateEffort;
    private identifyRequiredTools;
    private getIndustryPatterns;
    private requiresRegulatoryCompliance;
    private createRegulatoryRecommendation;
    private getIndustryBestPractices;
    private prioritizeRecommendations;
    private analyzePortfolio;
    private calculatePortfolioRisk;
    private calculateTimelineSpread;
    private determinePortfolioStrategy;
    private prioritizeProjects;
    private scoreProject;
    private generatePriorityRationale;
    private identifySynergies;
    private findCommonTechnologies;
    private inferTechnologies;
    private groupByUseCase;
    private optimizeResourceAllocation;
    private generateRecommendationId;
    private inferResourcesFromOpportunity;
    private identifyImpactMetric;
    private estimateImpactChange;
    private assessImplementationComplexity;
    private estimateTimeline;
    private identifyPrerequisites;
    private identifyResources;
    private defineSuccessCriteria;
}
export declare const recommendationEngine: RecommendationEngine;
//# sourceMappingURL=recommendation-engine.d.ts.map