@spaik/mcp-server-roi/dist/services/dutch-benchmark-validator.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, {
            p25: number;
            p75: number;
            source: string;
            average: number;
        }, {
            p25: number;
            p75: number;
            source: string;
            average: number;
        }>>;
    }, "strip", z.ZodTypeAny, {
        field: string;
        originalValue: number;
        adjustedValue: number;
        reason: string;
        severity: "warning" | "error" | "info";
        industryBenchmark?: {
            p25: number;
            p75: number;
            source: string;
            average: number;
        } | undefined;
    }, {
        field: string;
        originalValue: number;
        adjustedValue: number;
        reason: string;
        severity: "warning" | "error" | "info";
        industryBenchmark?: {
            p25: number;
            p75: number;
            source: string;
            average: number;
        } | 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, {
        metric: string;
        source: string;
        dutchMarketValue: number;
        globalValue: number;
        trend: string;
    }, {
        metric: string;
        source: 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, {
        title: string;
        url: string;
    }, {
        title: string;
        url: string;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    isValid: boolean;
    citations: {
        title: string;
        url: string;
    }[];
    validationIssues: {
        field: string;
        originalValue: number;
        adjustedValue: number;
        reason: string;
        severity: "warning" | "error" | "info";
        industryBenchmark?: {
            p25: number;
            p75: number;
            source: string;
            average: number;
        } | undefined;
    }[];
    marketInsights: {
        metric: string;
        source: string;
        dutchMarketValue: number;
        globalValue: number;
        trend: string;
    }[];
    recommendations: string[];
    adjustedInput?: any;
}, {
    isValid: boolean;
    citations: {
        title: string;
        url: string;
    }[];
    validationIssues: {
        field: string;
        originalValue: number;
        adjustedValue: number;
        reason: string;
        severity: "warning" | "error" | "info";
        industryBenchmark?: {
            p25: number;
            p75: number;
            source: string;
            average: number;
        } | undefined;
    }[];
    marketInsights: {
        metric: string;
        source: string;
        dutchMarketValue: number;
        globalValue: number;
        trend: string;
    }[];
    recommendations: string[];
    adjustedInput?: any;
}>;
export type ValidationResult = z.infer<typeof ValidationResultSchema>;
export declare class DutchBenchmarkValidator extends SonarBenchmarkService {
    private dutchLogger;
    constructor(apiKey: string);
    /**
     * Validate project inputs against Dutch market benchmarks
     */
    validateProjectInputs(params: {
        industry: string;
        useCases: UseCaseCreate[];
        implementationCosts: {
            software_licenses: number;
            development_hours: number;
            training_costs: number;
            infrastructure: number;
            ongoing_monthly: number;
        };
        timelineMonths: number;
    }): Promise<ValidationResult>;
    /**
     * Validate use case savings against Dutch benchmarks
     */
    private validateUseCaseSavings;
    /**
     * Validate implementation timeline
     */
    private validateTimeline;
    /**
     * Validate implementation costs
     */
    private validateImplementationCosts;
    /**
     * Fetch Dutch-specific benchmarks
     */
    private fetchDutchBenchmarks;
    /**
     * Fetch Dutch market insights
     */
    private fetchDutchMarketInsights;
    /**
     * Generate recommendations based on validation
     */
    private generateRecommendations;
    /**
     * Parse Dutch benchmark response
     */
    private parseDutchBenchmarks;
    /**
     * Parse market insights
     */
    private parseMarketInsights;
    /**
     * Get default Dutch benchmarks as fallback
     */
    private getDefaultDutchBenchmarks;
    /**
     * Convert benchmark data to Dutch-specific format
     */
    private convertBenchmarkDataToDutchFormat;
    /**
     * Convert ROI data to market insights
     */
    private convertROIDataToInsights;
}
//# sourceMappingURL=dutch-benchmark-validator.d.ts.map