@spaik/mcp-server-roi/dist/services/dutch-benchmark-validator-parallel.d.ts

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

import { z } from 'zod';
import { SonarBenchmarkService } from './sonar-benchmark-service.js';
import type { UseCaseCreate } from '../schemas/use-case.js';
export declare const ValidationResultSchema: z.ZodObject<{
    isValid: z.ZodBoolean;
    adjustedInput: z.ZodAny;
    validationIssues: z.ZodArray<z.ZodObject<{
        field: z.ZodString;
        originalValue: z.ZodNumber;
        adjustedValue: z.ZodNumber;
        reason: z.ZodString;
        severity: z.ZodEnum<["warning", "error", "info"]>;
        industryBenchmark: z.ZodOptional<z.ZodObject<{
            average: z.ZodNumber;
            p25: z.ZodNumber;
            p75: z.ZodNumber;
            source: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            average: number;
            p25: number;
            p75: number;
            source: string;
        }, {
            average: number;
            p25: number;
            p75: number;
            source: string;
        }>>;
    }, "strip", z.ZodTypeAny, {
        field: string;
        originalValue: number;
        adjustedValue: number;
        reason: string;
        severity: "warning" | "error" | "info";
        industryBenchmark?: {
            average: number;
            p25: number;
            p75: number;
            source: string;
        } | undefined;
    }, {
        field: string;
        originalValue: number;
        adjustedValue: number;
        reason: string;
        severity: "warning" | "error" | "info";
        industryBenchmark?: {
            average: number;
            p25: number;
            p75: number;
            source: string;
        } | undefined;
    }>, "many">;
    marketInsights: z.ZodArray<z.ZodObject<{
        metric: z.ZodString;
        dutchMarketValue: z.ZodNumber;
        globalValue: z.ZodNumber;
        trend: z.ZodString;
        source: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        source: string;
        metric: string;
        dutchMarketValue: number;
        globalValue: number;
        trend: string;
    }, {
        source: string;
        metric: string;
        dutchMarketValue: number;
        globalValue: number;
        trend: string;
    }>, "many">;
    recommendations: z.ZodArray<z.ZodString, "many">;
    citations: z.ZodArray<z.ZodObject<{
        url: z.ZodString;
        title: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        url: string;
        title: string;
    }, {
        url: string;
        title: string;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    isValid: boolean;
    validationIssues: {
        field: string;
        originalValue: number;
        adjustedValue: number;
        reason: string;
        severity: "warning" | "error" | "info";
        industryBenchmark?: {
            average: number;
            p25: number;
            p75: number;
            source: string;
        } | undefined;
    }[];
    marketInsights: {
        source: string;
        metric: string;
        dutchMarketValue: number;
        globalValue: number;
        trend: string;
    }[];
    recommendations: string[];
    citations: {
        url: string;
        title: string;
    }[];
    adjustedInput?: any;
}, {
    isValid: boolean;
    validationIssues: {
        field: string;
        originalValue: number;
        adjustedValue: number;
        reason: string;
        severity: "warning" | "error" | "info";
        industryBenchmark?: {
            average: number;
            p25: number;
            p75: number;
            source: string;
        } | undefined;
    }[];
    marketInsights: {
        source: string;
        metric: string;
        dutchMarketValue: number;
        globalValue: number;
        trend: string;
    }[];
    recommendations: string[];
    citations: {
        url: string;
        title: string;
    }[];
    adjustedInput?: any;
}>;
export type ValidationResult = z.infer<typeof ValidationResultSchema>;
/**
 * Enhanced Dutch Benchmark Validator with parallel API calls
 */
export declare class DutchBenchmarkValidatorParallel extends SonarBenchmarkService {
    private dutchLogger;
    constructor(apiKey: string);
    /**
     * Validate project inputs against Dutch market benchmarks with parallel API calls
     */
    validateProjectInputs(params: {
        industry: string;
        useCases: UseCaseCreate[];
        implementationCosts: {
            software_licenses: number;
            development_hours: number;
            training_costs: number;
            infrastructure: number;
            ongoing_monthly: number;
        };
        timelineMonths: number;
    }, correlationId?: string): Promise<ValidationResult>;
    /**
     * Fetch Dutch regulatory requirements
     */
    private fetchDutchRegulatoryRequirements;
    /**
     * Fetch competitor analysis
     */
    private fetchCompetitorAnalysis;
    /**
     * Fetch industry-specific data
     */
    private fetchIndustrySpecificData;
    /**
     * Generate enhanced recommendations with all data sources
     */
    private generateEnhancedRecommendations;
    /**
     * Default benchmarks for fallback
     */
    private getDefaultBenchmarks;
}
//# sourceMappingURL=dutch-benchmark-validator-parallel.d.ts.map