/**
 * Configuration validation using Zod schemas.
 *
 * Provides comprehensive validation with helpful error messages
 * for all bellwether.yaml configuration options.
 */
import { z } from 'zod';
/**
 * Server configuration schema.
 */
export declare const serverConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Command to start the MCP server */
    command: z.ZodDefault<z.ZodString>;
    /** Arguments to pass to the server command */
    args: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    /** Timeout for server startup and tool calls (ms) */
    timeout: z.ZodDefault<z.ZodNumber>;
    /** Transport type */
    transport: z.ZodDefault<z.ZodEnum<["stdio", "sse", "streamable-http"]>>;
    /** Remote MCP server URL (required for sse/streamable-http) */
    url: z.ZodDefault<z.ZodOptional<z.ZodString>>;
    /** Session ID for remote auth */
    sessionId: z.ZodDefault<z.ZodOptional<z.ZodString>>;
    /** Additional environment variables */
    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    /** Custom headers for remote server authentication */
    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
}, "strip", z.ZodTypeAny, {
    command: string;
    args: string[];
    transport: "stdio" | "sse" | "streamable-http";
    timeout: number;
    sessionId: string;
    url: string;
    headers?: Record<string, string> | undefined;
    env?: Record<string, string> | undefined;
}, {
    command?: string | undefined;
    args?: string[] | undefined;
    transport?: "stdio" | "sse" | "streamable-http" | undefined;
    timeout?: number | undefined;
    sessionId?: string | undefined;
    headers?: Record<string, string> | undefined;
    url?: string | undefined;
    env?: Record<string, string> | undefined;
}>>;
/**
 * LLM Ollama-specific settings.
 */
export declare const ollamaConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Ollama server base URL */
    baseUrl: z.ZodDefault<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    baseUrl: string;
}, {
    baseUrl?: string | undefined;
}>>;
/**
 * LLM configuration schema.
 */
export declare const llmConfigSchema: z.ZodDefault<z.ZodObject<{
    /** LLM provider */
    provider: z.ZodDefault<z.ZodEnum<["ollama", "openai", "anthropic"]>>;
    /** Model to use (empty = provider default) */
    model: z.ZodDefault<z.ZodString>;
    /** Ollama-specific settings */
    ollama: z.ZodDefault<z.ZodObject<{
        /** Ollama server base URL */
        baseUrl: z.ZodDefault<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        baseUrl: string;
    }, {
        baseUrl?: string | undefined;
    }>>;
    /** Environment variable for OpenAI API key */
    openaiApiKeyEnvVar: z.ZodOptional<z.ZodString>;
    /** Environment variable for Anthropic API key */
    anthropicApiKeyEnvVar: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    provider: "openai" | "anthropic" | "ollama";
    model: string;
    ollama: {
        baseUrl: string;
    };
    openaiApiKeyEnvVar?: string | undefined;
    anthropicApiKeyEnvVar?: string | undefined;
}, {
    provider?: "openai" | "anthropic" | "ollama" | undefined;
    model?: string | undefined;
    ollama?: {
        baseUrl?: string | undefined;
    } | undefined;
    openaiApiKeyEnvVar?: string | undefined;
    anthropicApiKeyEnvVar?: string | undefined;
}>>;
/**
 * Explore configuration schema (for bellwether explore command).
 */
export declare const exploreConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Personas to use for exploration */
    personas: z.ZodDefault<z.ZodArray<z.ZodEnum<["technical_writer", "security_tester", "qa_engineer", "novice_user"]>, "many">>;
    /** Maximum questions per tool */
    maxQuestionsPerTool: z.ZodDefault<z.ZodNumber>;
    /** Run personas in parallel */
    parallelPersonas: z.ZodDefault<z.ZodBoolean>;
    /** Maximum concurrent persona interviews */
    personaConcurrency: z.ZodDefault<z.ZodNumber>;
    /** Skip error/edge case testing */
    skipErrorTests: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    maxQuestionsPerTool: number;
    skipErrorTests: boolean;
    personas: ("technical_writer" | "security_tester" | "qa_engineer" | "novice_user")[];
    parallelPersonas: boolean;
    personaConcurrency: number;
}, {
    maxQuestionsPerTool?: number | undefined;
    skipErrorTests?: boolean | undefined;
    personas?: ("technical_writer" | "security_tester" | "qa_engineer" | "novice_user")[] | undefined;
    parallelPersonas?: boolean | undefined;
    personaConcurrency?: number | undefined;
}>>;
/**
 * Scenarios configuration schema.
 */
export declare const scenariosConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Path to scenarios YAML file */
    path: z.ZodOptional<z.ZodString>;
    /** Run only scenarios (no LLM tests) */
    only: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    only: boolean;
    path?: string | undefined;
}, {
    path?: string | undefined;
    only?: boolean | undefined;
}>>;
/**
 * Workflows configuration schema.
 */
export declare const workflowsConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Path to workflows YAML file */
    path: z.ZodOptional<z.ZodString>;
    /** Enable LLM-based workflow discovery */
    discover: z.ZodDefault<z.ZodBoolean>;
    /** Track state between workflow steps */
    trackState: z.ZodDefault<z.ZodBoolean>;
    /** Auto-generate workflows from discovered tools */
    autoGenerate: z.ZodDefault<z.ZodBoolean>;
    /** Skip steps whose dependencies (previous steps providing data) have failed */
    requireSuccessfulDependencies: z.ZodDefault<z.ZodBoolean>;
    /** Timeout per workflow step in milliseconds */
    stepTimeout: z.ZodDefault<z.ZodNumber>;
    /** Timeout configuration for workflow operations */
    timeouts: z.ZodDefault<z.ZodObject<{
        toolCall: z.ZodDefault<z.ZodNumber>;
        stateSnapshot: z.ZodDefault<z.ZodNumber>;
        probeTool: z.ZodDefault<z.ZodNumber>;
        llmAnalysis: z.ZodDefault<z.ZodNumber>;
        llmSummary: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        probeTool: number;
        toolCall: number;
        stateSnapshot: number;
        llmAnalysis: number;
        llmSummary: number;
    }, {
        probeTool?: number | undefined;
        toolCall?: number | undefined;
        stateSnapshot?: number | undefined;
        llmAnalysis?: number | undefined;
        llmSummary?: number | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    timeouts: {
        probeTool: number;
        toolCall: number;
        stateSnapshot: number;
        llmAnalysis: number;
        llmSummary: number;
    };
    stepTimeout: number;
    requireSuccessfulDependencies: boolean;
    discover: boolean;
    trackState: boolean;
    autoGenerate: boolean;
    path?: string | undefined;
}, {
    path?: string | undefined;
    timeouts?: {
        probeTool?: number | undefined;
        toolCall?: number | undefined;
        stateSnapshot?: number | undefined;
        llmAnalysis?: number | undefined;
        llmSummary?: number | undefined;
    } | undefined;
    stepTimeout?: number | undefined;
    requireSuccessfulDependencies?: boolean | undefined;
    discover?: boolean | undefined;
    trackState?: boolean | undefined;
    autoGenerate?: boolean | undefined;
}>>;
/**
 * Example output configuration schema.
 */
export declare const examplesConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Include full (non-truncated) examples */
    full: z.ZodDefault<z.ZodBoolean>;
    /** Maximum example length in characters */
    maxLength: z.ZodDefault<z.ZodNumber>;
    /** Maximum examples per tool */
    maxPerTool: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    maxLength: number;
    full: boolean;
    maxPerTool: number;
}, {
    maxLength?: number | undefined;
    full?: boolean | undefined;
    maxPerTool?: number | undefined;
}>>;
/**
 * Output file name configuration schema.
 */
export declare const outputFilesConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Check report JSON file name */
    checkReport: z.ZodDefault<z.ZodString>;
    /** Explore report JSON file name */
    exploreReport: z.ZodDefault<z.ZodString>;
    /** Contract documentation file name */
    contractDoc: z.ZodDefault<z.ZodString>;
    /** Agents documentation file name */
    agentsDoc: z.ZodDefault<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    checkReport: string;
    exploreReport: string;
    contractDoc: string;
    agentsDoc: string;
}, {
    checkReport?: string | undefined;
    exploreReport?: string | undefined;
    contractDoc?: string | undefined;
    agentsDoc?: string | undefined;
}>>;
/**
 * Output configuration schema.
 */
export declare const outputConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Output directory for JSON files (bellwether-check.json, etc.) */
    dir: z.ZodDefault<z.ZodString>;
    /** Output directory for documentation files (CONTRACT.md, AGENTS.md) */
    docsDir: z.ZodDefault<z.ZodString>;
    /** Output format */
    format: z.ZodDefault<z.ZodEffects<z.ZodEnum<["docs", "json", "both"]>, "json" | "both" | "docs", unknown>>;
    /** Example output settings */
    examples: z.ZodDefault<z.ZodObject<{
        /** Include full (non-truncated) examples */
        full: z.ZodDefault<z.ZodBoolean>;
        /** Maximum example length in characters */
        maxLength: z.ZodDefault<z.ZodNumber>;
        /** Maximum examples per tool */
        maxPerTool: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        maxLength: number;
        full: boolean;
        maxPerTool: number;
    }, {
        maxLength?: number | undefined;
        full?: boolean | undefined;
        maxPerTool?: number | undefined;
    }>>;
    /** Output file names */
    files: z.ZodDefault<z.ZodObject<{
        /** Check report JSON file name */
        checkReport: z.ZodDefault<z.ZodString>;
        /** Explore report JSON file name */
        exploreReport: z.ZodDefault<z.ZodString>;
        /** Contract documentation file name */
        contractDoc: z.ZodDefault<z.ZodString>;
        /** Agents documentation file name */
        agentsDoc: z.ZodDefault<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        checkReport: string;
        exploreReport: string;
        contractDoc: string;
        agentsDoc: string;
    }, {
        checkReport?: string | undefined;
        exploreReport?: string | undefined;
        contractDoc?: string | undefined;
        agentsDoc?: string | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    format: "json" | "both" | "docs";
    examples: {
        maxLength: number;
        full: boolean;
        maxPerTool: number;
    };
    dir: string;
    files: {
        checkReport: string;
        exploreReport: string;
        contractDoc: string;
        agentsDoc: string;
    };
    docsDir: string;
}, {
    format?: unknown;
    examples?: {
        maxLength?: number | undefined;
        full?: boolean | undefined;
        maxPerTool?: number | undefined;
    } | undefined;
    dir?: string | undefined;
    files?: {
        checkReport?: string | undefined;
        exploreReport?: string | undefined;
        contractDoc?: string | undefined;
        agentsDoc?: string | undefined;
    } | undefined;
    docsDir?: string | undefined;
}>>;
/**
 * Severity configuration schema.
 * Allows customizing how changes are classified and reported.
 */
export declare const severityConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Minimum severity level to include in reports */
    minimumSeverity: z.ZodDefault<z.ZodEnum<["none", "info", "warning", "breaking"]>>;
    /** Severity level at which to fail CI checks */
    failOnSeverity: z.ZodDefault<z.ZodEnum<["none", "info", "warning", "breaking"]>>;
    /** Suppress warning-level changes from output */
    suppressWarnings: z.ZodDefault<z.ZodBoolean>;
    /** Custom severity overrides per aspect */
    aspectOverrides: z.ZodOptional<z.ZodRecord<z.ZodEnum<["response_format", "response_structure", "response_schema_evolution", "error_handling", "error_pattern", "security", "performance", "schema", "description", "prompt", "resource", "server", "capability"]>, z.ZodEnum<["none", "info", "warning", "breaking"]>>>;
}, "strip", z.ZodTypeAny, {
    minimumSeverity: "none" | "info" | "warning" | "breaking";
    failOnSeverity: "none" | "info" | "warning" | "breaking";
    suppressWarnings: boolean;
    aspectOverrides?: Partial<Record<"error_handling" | "resource" | "server" | "security" | "response_format" | "response_structure" | "response_schema_evolution" | "error_pattern" | "performance" | "schema" | "description" | "prompt" | "capability", "none" | "info" | "warning" | "breaking">> | undefined;
}, {
    minimumSeverity?: "none" | "info" | "warning" | "breaking" | undefined;
    failOnSeverity?: "none" | "info" | "warning" | "breaking" | undefined;
    suppressWarnings?: boolean | undefined;
    aspectOverrides?: Partial<Record<"error_handling" | "resource" | "server" | "security" | "response_format" | "response_structure" | "response_schema_evolution" | "error_pattern" | "performance" | "schema" | "description" | "prompt" | "capability", "none" | "info" | "warning" | "breaking">> | undefined;
}>>;
/**
 * Security testing configuration schema.
 */
export declare const securityConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Enable security vulnerability testing */
    enabled: z.ZodDefault<z.ZodBoolean>;
    /** Security categories to test */
    categories: z.ZodDefault<z.ZodArray<z.ZodEnum<["sql_injection", "xss", "path_traversal", "command_injection", "ssrf", "error_disclosure"]>, "many">>;
}, "strip", z.ZodTypeAny, {
    enabled: boolean;
    categories: ("sql_injection" | "xss" | "path_traversal" | "command_injection" | "ssrf" | "error_disclosure")[];
}, {
    enabled?: boolean | undefined;
    categories?: ("sql_injection" | "xss" | "path_traversal" | "command_injection" | "ssrf" | "error_disclosure")[] | undefined;
}>>;
/**
 * Statistical sampling configuration schema.
 */
export declare const samplingConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Minimum samples per tool for statistical confidence */
    minSamples: z.ZodDefault<z.ZodNumber>;
    /** Target confidence level */
    targetConfidence: z.ZodDefault<z.ZodEnum<["low", "medium", "high"]>>;
    /** Fail if confidence is below target */
    failOnLowConfidence: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    minSamples: number;
    targetConfidence: "high" | "low" | "medium";
    failOnLowConfidence: boolean;
}, {
    minSamples?: number | undefined;
    targetConfidence?: "high" | "low" | "medium" | undefined;
    failOnLowConfidence?: boolean | undefined;
}>>;
/**
 * Metrics configuration schema.
 */
export declare const metricsConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Count validation rejections as success */
    countValidationAsSuccess: z.ZodDefault<z.ZodBoolean>;
    /** Separate validation metrics from reliability metrics */
    separateValidationMetrics: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    countValidationAsSuccess: boolean;
    separateValidationMetrics: boolean;
}, {
    countValidationAsSuccess?: boolean | undefined;
    separateValidationMetrics?: boolean | undefined;
}>>;
/**
 * Stateful testing configuration schema.
 */
export declare const statefulTestingConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Enable stateful tool testing */
    enabled: z.ZodDefault<z.ZodBoolean>;
    /** Maximum dependency chain length */
    maxChainLength: z.ZodDefault<z.ZodNumber>;
    /** Share outputs between dependent tools */
    shareOutputsBetweenTools: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    enabled: boolean;
    maxChainLength: number;
    shareOutputsBetweenTools: boolean;
}, {
    enabled?: boolean | undefined;
    maxChainLength?: number | undefined;
    shareOutputsBetweenTools?: boolean | undefined;
}>>;
/**
 * External service configuration schema.
 */
export declare const externalServiceConfigSchema: z.ZodObject<{
    /** Enable this external service */
    enabled: z.ZodOptional<z.ZodBoolean>;
    /** Sandbox credentials for this service */
    sandboxCredentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
}, "strip", z.ZodTypeAny, {
    enabled?: boolean | undefined;
    sandboxCredentials?: Record<string, string> | undefined;
}, {
    enabled?: boolean | undefined;
    sandboxCredentials?: Record<string, string> | undefined;
}>;
/**
 * External services handling configuration schema.
 */
export declare const externalServicesConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Mode for unconfigured services */
    mode: z.ZodDefault<z.ZodEnum<["skip", "mock", "fail"]>>;
    /** Per-service configuration overrides */
    services: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        /** Enable this external service */
        enabled: z.ZodOptional<z.ZodBoolean>;
        /** Sandbox credentials for this service */
        sandboxCredentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, "strip", z.ZodTypeAny, {
        enabled?: boolean | undefined;
        sandboxCredentials?: Record<string, string> | undefined;
    }, {
        enabled?: boolean | undefined;
        sandboxCredentials?: Record<string, string> | undefined;
    }>>>;
}, "strip", z.ZodTypeAny, {
    mode: "skip" | "mock" | "fail";
    services?: Record<string, {
        enabled?: boolean | undefined;
        sandboxCredentials?: Record<string, string> | undefined;
    }> | undefined;
}, {
    mode?: "skip" | "mock" | "fail" | undefined;
    services?: Record<string, {
        enabled?: boolean | undefined;
        sandboxCredentials?: Record<string, string> | undefined;
    }> | undefined;
}>>;
/**
 * Response assertion configuration schema.
 */
export declare const assertionsConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Enable response assertions */
    enabled: z.ZodDefault<z.ZodBoolean>;
    /** Strict mode fails on assertion violations */
    strict: z.ZodDefault<z.ZodBoolean>;
    /** Infer schemas from responses */
    infer: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    strict: boolean;
    enabled: boolean;
    infer: boolean;
}, {
    strict?: boolean | undefined;
    enabled?: boolean | undefined;
    infer?: boolean | undefined;
}>>;
/**
 * Rate limiting configuration schema.
 */
export declare const rateLimitConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Enable rate limiting */
    enabled: z.ZodDefault<z.ZodBoolean>;
    /** Requests per second */
    requestsPerSecond: z.ZodDefault<z.ZodNumber>;
    /** Burst limit */
    burstLimit: z.ZodDefault<z.ZodNumber>;
    /** Backoff strategy */
    backoffStrategy: z.ZodDefault<z.ZodEnum<["linear", "exponential"]>>;
    /** Maximum retries on rate limit */
    maxRetries: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    maxRetries: number;
    enabled: boolean;
    backoffStrategy: "linear" | "exponential";
    requestsPerSecond: number;
    burstLimit: number;
}, {
    maxRetries?: number | undefined;
    enabled?: boolean | undefined;
    backoffStrategy?: "linear" | "exponential" | undefined;
    requestsPerSecond?: number | undefined;
    burstLimit?: number | undefined;
}>>;
/**
 * Test fixture pattern schema.
 * Allows matching parameter names by regex pattern.
 */
export declare const testFixturePatternSchema: z.ZodObject<{
    /** Regex pattern to match parameter names */
    match: z.ZodString;
    /** Value to use for matching parameters */
    value: z.ZodUnknown;
}, "strip", z.ZodTypeAny, {
    match: string;
    value?: unknown;
}, {
    match: string;
    value?: unknown;
}>;
/**
 * Test fixtures configuration schema.
 * Allows users to customize test values for production server testing.
 */
export declare const testFixturesConfigSchema: z.ZodOptional<z.ZodObject<{
    /** Custom values for specific parameter names (exact match) */
    parameterValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    /** Custom values for parameters matching regex patterns */
    patterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
        /** Regex pattern to match parameter names */
        match: z.ZodString;
        /** Value to use for matching parameters */
        value: z.ZodUnknown;
    }, "strip", z.ZodTypeAny, {
        match: string;
        value?: unknown;
    }, {
        match: string;
        value?: unknown;
    }>, "many">>;
}, "strip", z.ZodTypeAny, {
    patterns?: {
        match: string;
        value?: unknown;
    }[] | undefined;
    parameterValues?: Record<string, unknown> | undefined;
}, {
    patterns?: {
        match: string;
        value?: unknown;
    }[] | undefined;
    parameterValues?: Record<string, unknown> | undefined;
}>>;
/**
 * Check command configuration schema.
 * Controls behavior of `bellwether check`.
 */
export declare const checkConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Enable incremental checking (only test tools with changed schemas) */
    incremental: z.ZodDefault<z.ZodBoolean>;
    /** Maximum age of cached results in hours (for incremental checking) */
    incrementalCacheHours: z.ZodDefault<z.ZodNumber>;
    /** Enable parallel tool testing (faster checks) */
    parallel: z.ZodDefault<z.ZodBoolean>;
    /** Number of concurrent tool workers (1-10) */
    parallelWorkers: z.ZodDefault<z.ZodNumber>;
    /** Performance regression threshold percentage (0-100, e.g., 25 = 25% slower triggers warning) */
    performanceThreshold: z.ZodDefault<z.ZodNumber>;
    /** Default diff output format */
    diffFormat: z.ZodDefault<z.ZodEnum<["text", "json", "compact", "github", "markdown", "junit", "sarif"]>>;
    /** Number of warmup runs before timing samples (excluded from variance calculation) */
    warmupRuns: z.ZodDefault<z.ZodNumber>;
    /** Enable smart test value generation from schema descriptions (e.g., YYYY-MM-DD dates) */
    smartTestValues: z.ZodDefault<z.ZodBoolean>;
    /** Stateful testing settings */
    statefulTesting: z.ZodDefault<z.ZodObject<{
        /** Enable stateful tool testing */
        enabled: z.ZodDefault<z.ZodBoolean>;
        /** Maximum dependency chain length */
        maxChainLength: z.ZodDefault<z.ZodNumber>;
        /** Share outputs between dependent tools */
        shareOutputsBetweenTools: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        enabled: boolean;
        maxChainLength: number;
        shareOutputsBetweenTools: boolean;
    }, {
        enabled?: boolean | undefined;
        maxChainLength?: number | undefined;
        shareOutputsBetweenTools?: boolean | undefined;
    }>>;
    /** External services handling */
    externalServices: z.ZodDefault<z.ZodObject<{
        /** Mode for unconfigured services */
        mode: z.ZodDefault<z.ZodEnum<["skip", "mock", "fail"]>>;
        /** Per-service configuration overrides */
        services: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            /** Enable this external service */
            enabled: z.ZodOptional<z.ZodBoolean>;
            /** Sandbox credentials for this service */
            sandboxCredentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, "strip", z.ZodTypeAny, {
            enabled?: boolean | undefined;
            sandboxCredentials?: Record<string, string> | undefined;
        }, {
            enabled?: boolean | undefined;
            sandboxCredentials?: Record<string, string> | undefined;
        }>>>;
    }, "strip", z.ZodTypeAny, {
        mode: "skip" | "mock" | "fail";
        services?: Record<string, {
            enabled?: boolean | undefined;
            sandboxCredentials?: Record<string, string> | undefined;
        }> | undefined;
    }, {
        mode?: "skip" | "mock" | "fail" | undefined;
        services?: Record<string, {
            enabled?: boolean | undefined;
            sandboxCredentials?: Record<string, string> | undefined;
        }> | undefined;
    }>>;
    /** Response assertions */
    assertions: z.ZodDefault<z.ZodObject<{
        /** Enable response assertions */
        enabled: z.ZodDefault<z.ZodBoolean>;
        /** Strict mode fails on assertion violations */
        strict: z.ZodDefault<z.ZodBoolean>;
        /** Infer schemas from responses */
        infer: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        strict: boolean;
        enabled: boolean;
        infer: boolean;
    }, {
        strict?: boolean | undefined;
        enabled?: boolean | undefined;
        infer?: boolean | undefined;
    }>>;
    /** Rate limit settings */
    rateLimit: z.ZodDefault<z.ZodObject<{
        /** Enable rate limiting */
        enabled: z.ZodDefault<z.ZodBoolean>;
        /** Requests per second */
        requestsPerSecond: z.ZodDefault<z.ZodNumber>;
        /** Burst limit */
        burstLimit: z.ZodDefault<z.ZodNumber>;
        /** Backoff strategy */
        backoffStrategy: z.ZodDefault<z.ZodEnum<["linear", "exponential"]>>;
        /** Maximum retries on rate limit */
        maxRetries: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        maxRetries: number;
        enabled: boolean;
        backoffStrategy: "linear" | "exponential";
        requestsPerSecond: number;
        burstLimit: number;
    }, {
        maxRetries?: number | undefined;
        enabled?: boolean | undefined;
        backoffStrategy?: "linear" | "exponential" | undefined;
        requestsPerSecond?: number | undefined;
        burstLimit?: number | undefined;
    }>>;
    /** Metrics configuration */
    metrics: z.ZodDefault<z.ZodObject<{
        /** Count validation rejections as success */
        countValidationAsSuccess: z.ZodDefault<z.ZodBoolean>;
        /** Separate validation metrics from reliability metrics */
        separateValidationMetrics: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        countValidationAsSuccess: boolean;
        separateValidationMetrics: boolean;
    }, {
        countValidationAsSuccess?: boolean | undefined;
        separateValidationMetrics?: boolean | undefined;
    }>>;
    /** Security testing settings */
    security: z.ZodDefault<z.ZodObject<{
        /** Enable security vulnerability testing */
        enabled: z.ZodDefault<z.ZodBoolean>;
        /** Security categories to test */
        categories: z.ZodDefault<z.ZodArray<z.ZodEnum<["sql_injection", "xss", "path_traversal", "command_injection", "ssrf", "error_disclosure"]>, "many">>;
    }, "strip", z.ZodTypeAny, {
        enabled: boolean;
        categories: ("sql_injection" | "xss" | "path_traversal" | "command_injection" | "ssrf" | "error_disclosure")[];
    }, {
        enabled?: boolean | undefined;
        categories?: ("sql_injection" | "xss" | "path_traversal" | "command_injection" | "ssrf" | "error_disclosure")[] | undefined;
    }>>;
    /** Statistical sampling settings */
    sampling: z.ZodDefault<z.ZodObject<{
        /** Minimum samples per tool for statistical confidence */
        minSamples: z.ZodDefault<z.ZodNumber>;
        /** Target confidence level */
        targetConfidence: z.ZodDefault<z.ZodEnum<["low", "medium", "high"]>>;
        /** Fail if confidence is below target */
        failOnLowConfidence: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        minSamples: number;
        targetConfidence: "high" | "low" | "medium";
        failOnLowConfidence: boolean;
    }, {
        minSamples?: number | undefined;
        targetConfidence?: "high" | "low" | "medium" | undefined;
        failOnLowConfidence?: boolean | undefined;
    }>>;
    /** Test fixtures for production server testing */
    testFixtures: z.ZodOptional<z.ZodObject<{
        /** Custom values for specific parameter names (exact match) */
        parameterValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        /** Custom values for parameters matching regex patterns */
        patterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
            /** Regex pattern to match parameter names */
            match: z.ZodString;
            /** Value to use for matching parameters */
            value: z.ZodUnknown;
        }, "strip", z.ZodTypeAny, {
            match: string;
            value?: unknown;
        }, {
            match: string;
            value?: unknown;
        }>, "many">>;
    }, "strip", z.ZodTypeAny, {
        patterns?: {
            match: string;
            value?: unknown;
        }[] | undefined;
        parameterValues?: Record<string, unknown> | undefined;
    }, {
        patterns?: {
            match: string;
            value?: unknown;
        }[] | undefined;
        parameterValues?: Record<string, unknown> | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    security: {
        enabled: boolean;
        categories: ("sql_injection" | "xss" | "path_traversal" | "command_injection" | "ssrf" | "error_disclosure")[];
    };
    warmupRuns: number;
    externalServices: {
        mode: "skip" | "mock" | "fail";
        services?: Record<string, {
            enabled?: boolean | undefined;
            sandboxCredentials?: Record<string, string> | undefined;
        }> | undefined;
    };
    assertions: {
        strict: boolean;
        enabled: boolean;
        infer: boolean;
    };
    rateLimit: {
        maxRetries: number;
        enabled: boolean;
        backoffStrategy: "linear" | "exponential";
        requestsPerSecond: number;
        burstLimit: number;
    };
    statefulTesting: {
        enabled: boolean;
        maxChainLength: number;
        shareOutputsBetweenTools: boolean;
    };
    parallel: boolean;
    incremental: boolean;
    incrementalCacheHours: number;
    parallelWorkers: number;
    performanceThreshold: number;
    diffFormat: "text" | "json" | "markdown" | "github" | "compact" | "junit" | "sarif";
    smartTestValues: boolean;
    metrics: {
        countValidationAsSuccess: boolean;
        separateValidationMetrics: boolean;
    };
    sampling: {
        minSamples: number;
        targetConfidence: "high" | "low" | "medium";
        failOnLowConfidence: boolean;
    };
    testFixtures?: {
        patterns?: {
            match: string;
            value?: unknown;
        }[] | undefined;
        parameterValues?: Record<string, unknown> | undefined;
    } | undefined;
}, {
    security?: {
        enabled?: boolean | undefined;
        categories?: ("sql_injection" | "xss" | "path_traversal" | "command_injection" | "ssrf" | "error_disclosure")[] | undefined;
    } | undefined;
    warmupRuns?: number | undefined;
    externalServices?: {
        mode?: "skip" | "mock" | "fail" | undefined;
        services?: Record<string, {
            enabled?: boolean | undefined;
            sandboxCredentials?: Record<string, string> | undefined;
        }> | undefined;
    } | undefined;
    assertions?: {
        strict?: boolean | undefined;
        enabled?: boolean | undefined;
        infer?: boolean | undefined;
    } | undefined;
    rateLimit?: {
        maxRetries?: number | undefined;
        enabled?: boolean | undefined;
        backoffStrategy?: "linear" | "exponential" | undefined;
        requestsPerSecond?: number | undefined;
        burstLimit?: number | undefined;
    } | undefined;
    statefulTesting?: {
        enabled?: boolean | undefined;
        maxChainLength?: number | undefined;
        shareOutputsBetweenTools?: boolean | undefined;
    } | undefined;
    testFixtures?: {
        patterns?: {
            match: string;
            value?: unknown;
        }[] | undefined;
        parameterValues?: Record<string, unknown> | undefined;
    } | undefined;
    parallel?: boolean | undefined;
    incremental?: boolean | undefined;
    incrementalCacheHours?: number | undefined;
    parallelWorkers?: number | undefined;
    performanceThreshold?: number | undefined;
    diffFormat?: "text" | "json" | "markdown" | "github" | "compact" | "junit" | "sarif" | undefined;
    smartTestValues?: boolean | undefined;
    metrics?: {
        countValidationAsSuccess?: boolean | undefined;
        separateValidationMetrics?: boolean | undefined;
    } | undefined;
    sampling?: {
        minSamples?: number | undefined;
        targetConfidence?: "high" | "low" | "medium" | undefined;
        failOnLowConfidence?: boolean | undefined;
    } | undefined;
}>>;
/**
 * Baseline configuration schema.
 */
export declare const baselineConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Default baseline file path (relative to output.dir or absolute) */
    path: z.ZodDefault<z.ZodString>;
    /** Path to save baseline after check (enables auto-save) */
    savePath: z.ZodOptional<z.ZodString>;
    /** Path to baseline for comparison (drift detection) */
    comparePath: z.ZodOptional<z.ZodString>;
    /** Fail if drift is detected */
    failOnDrift: z.ZodDefault<z.ZodBoolean>;
    /** Default output format for baseline comparisons */
    outputFormat: z.ZodDefault<z.ZodEnum<["text", "json", "markdown", "compact"]>>;
    /** Severity thresholds for filtering and CI failure */
    severity: z.ZodDefault<z.ZodObject<{
        /** Minimum severity level to include in reports */
        minimumSeverity: z.ZodDefault<z.ZodEnum<["none", "info", "warning", "breaking"]>>;
        /** Severity level at which to fail CI checks */
        failOnSeverity: z.ZodDefault<z.ZodEnum<["none", "info", "warning", "breaking"]>>;
        /** Suppress warning-level changes from output */
        suppressWarnings: z.ZodDefault<z.ZodBoolean>;
        /** Custom severity overrides per aspect */
        aspectOverrides: z.ZodOptional<z.ZodRecord<z.ZodEnum<["response_format", "response_structure", "response_schema_evolution", "error_handling", "error_pattern", "security", "performance", "schema", "description", "prompt", "resource", "server", "capability"]>, z.ZodEnum<["none", "info", "warning", "breaking"]>>>;
    }, "strip", z.ZodTypeAny, {
        minimumSeverity: "none" | "info" | "warning" | "breaking";
        failOnSeverity: "none" | "info" | "warning" | "breaking";
        suppressWarnings: boolean;
        aspectOverrides?: Partial<Record<"error_handling" | "resource" | "server" | "security" | "response_format" | "response_structure" | "response_schema_evolution" | "error_pattern" | "performance" | "schema" | "description" | "prompt" | "capability", "none" | "info" | "warning" | "breaking">> | undefined;
    }, {
        minimumSeverity?: "none" | "info" | "warning" | "breaking" | undefined;
        failOnSeverity?: "none" | "info" | "warning" | "breaking" | undefined;
        suppressWarnings?: boolean | undefined;
        aspectOverrides?: Partial<Record<"error_handling" | "resource" | "server" | "security" | "response_format" | "response_structure" | "response_schema_evolution" | "error_pattern" | "performance" | "schema" | "description" | "prompt" | "capability", "none" | "info" | "warning" | "breaking">> | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    severity: {
        minimumSeverity: "none" | "info" | "warning" | "breaking";
        failOnSeverity: "none" | "info" | "warning" | "breaking";
        suppressWarnings: boolean;
        aspectOverrides?: Partial<Record<"error_handling" | "resource" | "server" | "security" | "response_format" | "response_structure" | "response_schema_evolution" | "error_pattern" | "performance" | "schema" | "description" | "prompt" | "capability", "none" | "info" | "warning" | "breaking">> | undefined;
    };
    path: string;
    failOnDrift: boolean;
    outputFormat: "text" | "json" | "markdown" | "compact";
    savePath?: string | undefined;
    comparePath?: string | undefined;
}, {
    severity?: {
        minimumSeverity?: "none" | "info" | "warning" | "breaking" | undefined;
        failOnSeverity?: "none" | "info" | "warning" | "breaking" | undefined;
        suppressWarnings?: boolean | undefined;
        aspectOverrides?: Partial<Record<"error_handling" | "resource" | "server" | "security" | "response_format" | "response_structure" | "response_schema_evolution" | "error_pattern" | "performance" | "schema" | "description" | "prompt" | "capability", "none" | "info" | "warning" | "breaking">> | undefined;
    } | undefined;
    path?: string | undefined;
    savePath?: string | undefined;
    comparePath?: string | undefined;
    failOnDrift?: boolean | undefined;
    outputFormat?: "text" | "json" | "markdown" | "compact" | undefined;
}>>;
/**
 * Cache configuration schema.
 */
export declare const cacheConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Enable response caching */
    enabled: z.ZodDefault<z.ZodBoolean>;
    /** Cache directory */
    dir: z.ZodDefault<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    enabled: boolean;
    dir: string;
}, {
    enabled?: boolean | undefined;
    dir?: string | undefined;
}>>;
/**
 * Logging configuration schema.
 */
export declare const loggingConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Log level */
    level: z.ZodDefault<z.ZodEnum<["debug", "info", "warn", "error", "silent"]>>;
    /** Verbose output */
    verbose: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    level: "info" | "error" | "debug" | "warn" | "silent";
    verbose: boolean;
}, {
    level?: "info" | "error" | "debug" | "warn" | "silent" | undefined;
    verbose?: boolean | undefined;
}>>;
/**
 * Watch mode configuration schema.
 */
export declare const watchConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Path to watch for changes */
    path: z.ZodDefault<z.ZodString>;
    /** Polling interval in milliseconds */
    interval: z.ZodDefault<z.ZodNumber>;
    /** File extensions to watch */
    extensions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    /** Command to run when drift is detected */
    onDrift: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    path: string;
    interval: number;
    extensions: string[];
    onDrift?: string | undefined;
}, {
    path?: string | undefined;
    interval?: number | undefined;
    extensions?: string[] | undefined;
    onDrift?: string | undefined;
}>>;
/**
 * Discovery configuration schema.
 */
export declare const discoveryConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Output as JSON */
    json: z.ZodDefault<z.ZodBoolean>;
    /** Connection timeout in ms */
    timeout: z.ZodDefault<z.ZodNumber>;
    /** Transport type */
    transport: z.ZodDefault<z.ZodEnum<["stdio", "sse", "streamable-http"]>>;
    /** Remote MCP server URL */
    url: z.ZodDefault<z.ZodOptional<z.ZodString>>;
    /** Session ID for remote auth */
    sessionId: z.ZodDefault<z.ZodOptional<z.ZodString>>;
    /** Custom headers for remote server authentication */
    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
}, "strip", z.ZodTypeAny, {
    transport: "stdio" | "sse" | "streamable-http";
    timeout: number;
    sessionId: string;
    url: string;
    json: boolean;
    headers?: Record<string, string> | undefined;
}, {
    transport?: "stdio" | "sse" | "streamable-http" | undefined;
    timeout?: number | undefined;
    sessionId?: string | undefined;
    headers?: Record<string, string> | undefined;
    url?: string | undefined;
    json?: boolean | undefined;
}>>;
/**
 * Registry configuration schema.
 */
export declare const registryConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Maximum results to show */
    limit: z.ZodDefault<z.ZodNumber>;
    /** Output as JSON */
    json: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    json: boolean;
    limit: number;
}, {
    json?: boolean | undefined;
    limit?: number | undefined;
}>>;
/**
 * Golden command configuration schema.
 */
export declare const goldenConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Default JSON args for golden save */
    defaultArgs: z.ZodDefault<z.ZodString>;
    /** Default comparison mode for golden save */
    mode: z.ZodDefault<z.ZodEnum<["exact", "structural", "semantic"]>>;
    /** Output format for compare */
    compareFormat: z.ZodDefault<z.ZodEnum<["text", "json", "markdown"]>>;
    /** Output format for list */
    listFormat: z.ZodDefault<z.ZodEnum<["text", "json"]>>;
    /** Normalize timestamps by default */
    normalizeTimestamps: z.ZodDefault<z.ZodBoolean>;
    /** Normalize UUIDs by default */
    normalizeUuids: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    mode: "structural" | "exact" | "semantic";
    defaultArgs: string;
    compareFormat: "text" | "json" | "markdown";
    listFormat: "text" | "json";
    normalizeTimestamps: boolean;
    normalizeUuids: boolean;
}, {
    mode?: "structural" | "exact" | "semantic" | undefined;
    defaultArgs?: string | undefined;
    compareFormat?: "text" | "json" | "markdown" | undefined;
    listFormat?: "text" | "json" | undefined;
    normalizeTimestamps?: boolean | undefined;
    normalizeUuids?: boolean | undefined;
}>>;
/**
 * Contract command configuration schema.
 */
export declare const contractConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Default contract file path */
    path: z.ZodOptional<z.ZodString>;
    /** Validation mode */
    mode: z.ZodDefault<z.ZodEnum<["strict", "lenient", "report"]>>;
    /** Output format */
    format: z.ZodDefault<z.ZodEnum<["text", "json", "markdown"]>>;
    /** Server startup timeout */
    timeout: z.ZodDefault<z.ZodNumber>;
    /** Exit with error when violations are found */
    failOnViolation: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    mode: "strict" | "lenient" | "report";
    format: "text" | "json" | "markdown";
    timeout: number;
    failOnViolation: boolean;
    path?: string | undefined;
}, {
    mode?: "strict" | "lenient" | "report" | undefined;
    format?: "text" | "json" | "markdown" | undefined;
    timeout?: number | undefined;
    path?: string | undefined;
    failOnViolation?: boolean | undefined;
}>>;
/**
 * Complete bellwether.yaml configuration schema.
 *
 * This config is used by both 'bellwether check' and 'bellwether explore' commands.
 * Each command uses the relevant sections.
 */
export declare const bellwetherConfigSchema: z.ZodObject<{
    /** Server configuration (used by both commands) */
    server: z.ZodDefault<z.ZodObject<{
        /** Command to start the MCP server */
        command: z.ZodDefault<z.ZodString>;
        /** Arguments to pass to the server command */
        args: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        /** Timeout for server startup and tool calls (ms) */
        timeout: z.ZodDefault<z.ZodNumber>;
        /** Transport type */
        transport: z.ZodDefault<z.ZodEnum<["stdio", "sse", "streamable-http"]>>;
        /** Remote MCP server URL (required for sse/streamable-http) */
        url: z.ZodDefault<z.ZodOptional<z.ZodString>>;
        /** Session ID for remote auth */
        sessionId: z.ZodDefault<z.ZodOptional<z.ZodString>>;
        /** Additional environment variables */
        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        /** Custom headers for remote server authentication */
        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, "strip", z.ZodTypeAny, {
        command: string;
        args: string[];
        transport: "stdio" | "sse" | "streamable-http";
        timeout: number;
        sessionId: string;
        url: string;
        headers?: Record<string, string> | undefined;
        env?: Record<string, string> | undefined;
    }, {
        command?: string | undefined;
        args?: string[] | undefined;
        transport?: "stdio" | "sse" | "streamable-http" | undefined;
        timeout?: number | undefined;
        sessionId?: string | undefined;
        headers?: Record<string, string> | undefined;
        url?: string | undefined;
        env?: Record<string, string> | undefined;
    }>>;
    /** LLM configuration (used by explore command) */
    llm: z.ZodDefault<z.ZodObject<{
        /** LLM provider */
        provider: z.ZodDefault<z.ZodEnum<["ollama", "openai", "anthropic"]>>;
        /** Model to use (empty = provider default) */
        model: z.ZodDefault<z.ZodString>;
        /** Ollama-specific settings */
        ollama: z.ZodDefault<z.ZodObject<{
            /** Ollama server base URL */
            baseUrl: z.ZodDefault<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            baseUrl: string;
        }, {
            baseUrl?: string | undefined;
        }>>;
        /** Environment variable for OpenAI API key */
        openaiApiKeyEnvVar: z.ZodOptional<z.ZodString>;
        /** Environment variable for Anthropic API key */
        anthropicApiKeyEnvVar: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        provider: "openai" | "anthropic" | "ollama";
        model: string;
        ollama: {
            baseUrl: string;
        };
        openaiApiKeyEnvVar?: string | undefined;
        anthropicApiKeyEnvVar?: string | undefined;
    }, {
        provider?: "openai" | "anthropic" | "ollama" | undefined;
        model?: string | undefined;
        ollama?: {
            baseUrl?: string | undefined;
        } | undefined;
        openaiApiKeyEnvVar?: string | undefined;
        anthropicApiKeyEnvVar?: string | undefined;
    }>>;
    /** Explore settings (used by explore command) */
    explore: z.ZodDefault<z.ZodObject<{
        /** Personas to use for exploration */
        personas: z.ZodDefault<z.ZodArray<z.ZodEnum<["technical_writer", "security_tester", "qa_engineer", "novice_user"]>, "many">>;
        /** Maximum questions per tool */
        maxQuestionsPerTool: z.ZodDefault<z.ZodNumber>;
        /** Run personas in parallel */
        parallelPersonas: z.ZodDefault<z.ZodBoolean>;
        /** Maximum concurrent persona interviews */
        personaConcurrency: z.ZodDefault<z.ZodNumber>;
        /** Skip error/edge case testing */
        skipErrorTests: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        maxQuestionsPerTool: number;
        skipErrorTests: boolean;
        personas: ("technical_writer" | "security_tester" | "qa_engineer" | "novice_user")[];
        parallelPersonas: boolean;
        personaConcurrency: number;
    }, {
        maxQuestionsPerTool?: number | undefined;
        skipErrorTests?: boolean | undefined;
        personas?: ("technical_writer" | "security_tester" | "qa_engineer" | "novice_user")[] | undefined;
        parallelPersonas?: boolean | undefined;
        personaConcurrency?: number | undefined;
    }>>;
    /** Check settings (used by check command) */
    check: z.ZodDefault<z.ZodObject<{
        /** Enable incremental checking (only test tools with changed schemas) */
        incremental: z.ZodDefault<z.ZodBoolean>;
        /** Maximum age of cached results in hours (for incremental checking) */
        incrementalCacheHours: z.ZodDefault<z.ZodNumber>;
        /** Enable parallel tool testing (faster checks) */
        parallel: z.ZodDefault<z.ZodBoolean>;
        /** Number of concurrent tool workers (1-10) */
        parallelWorkers: z.ZodDefault<z.ZodNumber>;
        /** Performance regression threshold percentage (0-100, e.g., 25 = 25% slower triggers warning) */
        performanceThreshold: z.ZodDefault<z.ZodNumber>;
        /** Default diff output format */
        diffFormat: z.ZodDefault<z.ZodEnum<["text", "json", "compact", "github", "markdown", "junit", "sarif"]>>;
        /** Number of warmup runs before timing samples (excluded from variance calculation) */
        warmupRuns: z.ZodDefault<z.ZodNumber>;
        /** Enable smart test value generation from schema descriptions (e.g., YYYY-MM-DD dates) */
        smartTestValues: z.ZodDefault<z.ZodBoolean>;
        /** Stateful testing settings */
        statefulTesting: z.ZodDefault<z.ZodObject<{
            /** Enable stateful tool testing */
            enabled: z.ZodDefault<z.ZodBoolean>;
            /** Maximum dependency chain length */
            maxChainLength: z.ZodDefault<z.ZodNumber>;
            /** Share outputs between dependent tools */
            shareOutputsBetweenTools: z.ZodDefault<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            enabled: boolean;
            maxChainLength: number;
            shareOutputsBetweenTools: boolean;
        }, {
            enabled?: boolean | undefined;
            maxChainLength?: number | undefined;
            shareOutputsBetweenTools?: boolean | undefined;
        }>>;
        /** External services handling */
        externalServices: z.ZodDefault<z.ZodObject<{
            /** Mode for unconfigured services */
            mode: z.ZodDefault<z.ZodEnum<["skip", "mock", "fail"]>>;
            /** Per-service configuration overrides */
            services: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                /** Enable this external service */
                enabled: z.ZodOptional<z.ZodBoolean>;
                /** Sandbox credentials for this service */
                sandboxCredentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            }, "strip", z.ZodTypeAny, {
                enabled?: boolean | undefined;
                sandboxCredentials?: Record<string, string> | undefined;
            }, {
                enabled?: boolean | undefined;
                sandboxCredentials?: Record<string, string> | undefined;
            }>>>;
        }, "strip", z.ZodTypeAny, {
            mode: "skip" | "mock" | "fail";
            services?: Record<string, {
                enabled?: boolean | undefined;
                sandboxCredentials?: Record<string, string> | undefined;
            }> | undefined;
        }, {
            mode?: "skip" | "mock" | "fail" | undefined;
            services?: Record<string, {
                enabled?: boolean | undefined;
                sandboxCredentials?: Record<string, string> | undefined;
            }> | undefined;
        }>>;
        /** Response assertions */
        assertions: z.ZodDefault<z.ZodObject<{
            /** Enable response assertions */
            enabled: z.ZodDefault<z.ZodBoolean>;
            /** Strict mode fails on assertion violations */
            strict: z.ZodDefault<z.ZodBoolean>;
            /** Infer schemas from responses */
            infer: z.ZodDefault<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            strict: boolean;
            enabled: boolean;
            infer: boolean;
        }, {
            strict?: boolean | undefined;
            enabled?: boolean | undefined;
            infer?: boolean | undefined;
        }>>;
        /** Rate limit settings */
        rateLimit: z.ZodDefault<z.ZodObject<{
            /** Enable rate limiting */
            enabled: z.ZodDefault<z.ZodBoolean>;
            /** Requests per second */
            requestsPerSecond: z.ZodDefault<z.ZodNumber>;
            /** Burst limit */
            burstLimit: z.ZodDefault<z.ZodNumber>;
            /** Backoff strategy */
            backoffStrategy: z.ZodDefault<z.ZodEnum<["linear", "exponential"]>>;
            /** Maximum retries on rate limit */
            maxRetries: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            maxRetries: number;
            enabled: boolean;
            backoffStrategy: "linear" | "exponential";
            requestsPerSecond: number;
            burstLimit: number;
        }, {
            maxRetries?: number | undefined;
            enabled?: boolean | undefined;
            backoffStrategy?: "linear" | "exponential" | undefined;
            requestsPerSecond?: number | undefined;
            burstLimit?: number | undefined;
        }>>;
        /** Metrics configuration */
        metrics: z.ZodDefault<z.ZodObject<{
            /** Count validation rejections as success */
            countValidationAsSuccess: z.ZodDefault<z.ZodBoolean>;
            /** Separate validation metrics from reliability metrics */
            separateValidationMetrics: z.ZodDefault<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            countValidationAsSuccess: boolean;
            separateValidationMetrics: boolean;
        }, {
            countValidationAsSuccess?: boolean | undefined;
            separateValidationMetrics?: boolean | undefined;
        }>>;
        /** Security testing settings */
        security: z.ZodDefault<z.ZodObject<{
            /** Enable security vulnerability testing */
            enabled: z.ZodDefault<z.ZodBoolean>;
            /** Security categories to test */
            categories: z.ZodDefault<z.ZodArray<z.ZodEnum<["sql_injection", "xss", "path_traversal", "command_injection", "ssrf", "error_disclosure"]>, "many">>;
        }, "strip", z.ZodTypeAny, {
            enabled: boolean;
            categories: ("sql_injection" | "xss" | "path_traversal" | "command_injection" | "ssrf" | "error_disclosure")[];
        }, {
            enabled?: boolean | undefined;
            categories?: ("sql_injection" | "xss" | "path_traversal" | "command_injection" | "ssrf" | "error_disclosure")[] | undefined;
        }>>;
        /** Statistical sampling settings */
        sampling: z.ZodDefault<z.ZodObject<{
            /** Minimum samples per tool for statistical confidence */
            minSamples: z.ZodDefault<z.ZodNumber>;
            /** Target confidence level */
            targetConfidence: z.ZodDefault<z.ZodEnum<["low", "medium", "high"]>>;
            /** Fail if confidence is below target */
            failOnLowConfidence: z.ZodDefault<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            minSamples: number;
            targetConfidence: "high" | "low" | "medium";
            failOnLowConfidence: boolean;
        }, {
            minSamples?: number | undefined;
            targetConfidence?: "high" | "low" | "medium" | undefined;
            failOnLowConfidence?: boolean | undefined;
        }>>;
        /** Test fixtures for production server testing */
        testFixtures: z.ZodOptional<z.ZodObject<{
            /** Custom values for specific parameter names (exact match) */
            parameterValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            /** Custom values for parameters matching regex patterns */
            patterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
                /** Regex pattern to match parameter names */
                match: z.ZodString;
                /** Value to use for matching parameters */
                value: z.ZodUnknown;
            }, "strip", z.ZodTypeAny, {
                match: string;
                value?: unknown;
            }, {
                match: string;
                value?: unknown;
            }>, "many">>;
        }, "strip", z.ZodTypeAny, {
            patterns?: {
                match: string;
                value?: unknown;
            }[] | undefined;
            parameterValues?: Record<string, unknown> | undefined;
        }, {
            patterns?: {
                match: string;
                value?: unknown;
            }[] | undefined;
            parameterValues?: Record<string, unknown> | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        security: {
            enabled: boolean;
            categories: ("sql_injection" | "xss" | "path_traversal" | "command_injection" | "ssrf" | "error_disclosure")[];
        };
        warmupRuns: number;
        externalServices: {
            mode: "skip" | "mock" | "fail";
            services?: Record<string, {
                enabled?: boolean | undefined;
                sandboxCredentials?: Record<string, string> | undefined;
            }> | undefined;
        };
        assertions: {
            strict: boolean;
            enabled: boolean;
            infer: boolean;
        };
        rateLimit: {
            maxRetries: number;
            enabled: boolean;
            backoffStrategy: "linear" | "exponential";
            requestsPerSecond: number;
            burstLimit: number;
        };
        statefulTesting: {
            enabled: boolean;
            maxChainLength: number;
            shareOutputsBetweenTools: boolean;
        };
        parallel: boolean;
        incremental: boolean;
        incrementalCacheHours: number;
        parallelWorkers: number;
        performanceThreshold: number;
        diffFormat: "text" | "json" | "markdown" | "github" | "compact" | "junit" | "sarif";
        smartTestValues: boolean;
        metrics: {
            countValidationAsSuccess: boolean;
            separateValidationMetrics: boolean;
        };
        sampling: {
            minSamples: number;
            targetConfidence: "high" | "low" | "medium";
            failOnLowConfidence: boolean;
        };
        testFixtures?: {
            patterns?: {
                match: string;
                value?: unknown;
            }[] | undefined;
            parameterValues?: Record<string, unknown> | undefined;
        } | undefined;
    }, {
        security?: {
            enabled?: boolean | undefined;
            categories?: ("sql_injection" | "xss" | "path_traversal" | "command_injection" | "ssrf" | "error_disclosure")[] | undefined;
        } | undefined;
        warmupRuns?: number | undefined;
        externalServices?: {
            mode?: "skip" | "mock" | "fail" | undefined;
            services?: Record<string, {
                enabled?: boolean | undefined;
                sandboxCredentials?: Record<string, string> | undefined;
            }> | undefined;
        } | undefined;
        assertions?: {
            strict?: boolean | undefined;
            enabled?: boolean | undefined;
            infer?: boolean | undefined;
        } | undefined;
        rateLimit?: {
            maxRetries?: number | undefined;
            enabled?: boolean | undefined;
            backoffStrategy?: "linear" | "exponential" | undefined;
            requestsPerSecond?: number | undefined;
            burstLimit?: number | undefined;
        } | undefined;
        statefulTesting?: {
            enabled?: boolean | undefined;
            maxChainLength?: number | undefined;
            shareOutputsBetweenTools?: boolean | undefined;
        } | undefined;
        testFixtures?: {
            patterns?: {
                match: string;
                value?: unknown;
            }[] | undefined;
            parameterValues?: Record<string, unknown> | undefined;
        } | undefined;
        parallel?: boolean | undefined;
        incremental?: boolean | undefined;
        incrementalCacheHours?: number | undefined;
        parallelWorkers?: number | undefined;
        performanceThreshold?: number | undefined;
        diffFormat?: "text" | "json" | "markdown" | "github" | "compact" | "junit" | "sarif" | undefined;
        smartTestValues?: boolean | undefined;
        metrics?: {
            countValidationAsSuccess?: boolean | undefined;
            separateValidationMetrics?: boolean | undefined;
        } | undefined;
        sampling?: {
            minSamples?: number | undefined;
            targetConfidence?: "high" | "low" | "medium" | undefined;
            failOnLowConfidence?: boolean | undefined;
        } | undefined;
    }>>;
    /** Custom scenarios (used by both commands) */
    scenarios: z.ZodDefault<z.ZodObject<{
        /** Path to scenarios YAML file */
        path: z.ZodOptional<z.ZodString>;
        /** Run only scenarios (no LLM tests) */
        only: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        only: boolean;
        path?: string | undefined;
    }, {
        path?: string | undefined;
        only?: boolean | undefined;
    }>>;
    /** Workflow testing (used by explore command) */
    workflows: z.ZodDefault<z.ZodObject<{
        /** Path to workflows YAML file */
        path: z.ZodOptional<z.ZodString>;
        /** Enable LLM-based workflow discovery */
        discover: z.ZodDefault<z.ZodBoolean>;
        /** Track state between workflow steps */
        trackState: z.ZodDefault<z.ZodBoolean>;
        /** Auto-generate workflows from discovered tools */
        autoGenerate: z.ZodDefault<z.ZodBoolean>;
        /** Skip steps whose dependencies (previous steps providing data) have failed */
        requireSuccessfulDependencies: z.ZodDefault<z.ZodBoolean>;
        /** Timeout per workflow step in milliseconds */
        stepTimeout: z.ZodDefault<z.ZodNumber>;
        /** Timeout configuration for workflow operations */
        timeouts: z.ZodDefault<z.ZodObject<{
            toolCall: z.ZodDefault<z.ZodNumber>;
            stateSnapshot: z.ZodDefault<z.ZodNumber>;
            probeTool: z.ZodDefault<z.ZodNumber>;
            llmAnalysis: z.ZodDefault<z.ZodNumber>;
            llmSummary: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            probeTool: number;
            toolCall: number;
            stateSnapshot: number;
            llmAnalysis: number;
            llmSummary: number;
        }, {
            probeTool?: number | undefined;
            toolCall?: number | undefined;
            stateSnapshot?: number | undefined;
            llmAnalysis?: number | undefined;
            llmSummary?: number | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        timeouts: {
            probeTool: number;
            toolCall: number;
            stateSnapshot: number;
            llmAnalysis: number;
            llmSummary: number;
        };
        stepTimeout: number;
        requireSuccessfulDependencies: boolean;
        discover: boolean;
        trackState: boolean;
        autoGenerate: boolean;
        path?: string | undefined;
    }, {
        path?: string | undefined;
        timeouts?: {
            probeTool?: number | undefined;
            toolCall?: number | undefined;
            stateSnapshot?: number | undefined;
            llmAnalysis?: number | undefined;
            llmSummary?: number | undefined;
        } | undefined;
        stepTimeout?: number | undefined;
        requireSuccessfulDependencies?: boolean | undefined;
        discover?: boolean | undefined;
        trackState?: boolean | undefined;
        autoGenerate?: boolean | undefined;
    }>>;
    /** Output settings (used by both commands) */
    output: z.ZodDefault<z.ZodObject<{
        /** Output directory for JSON files (bellwether-check.json, etc.) */
        dir: z.ZodDefault<z.ZodString>;
        /** Output directory for documentation files (CONTRACT.md, AGENTS.md) */
        docsDir: z.ZodDefault<z.ZodString>;
        /** Output format */
        format: z.ZodDefault<z.ZodEffects<z.ZodEnum<["docs", "json", "both"]>, "json" | "both" | "docs", unknown>>;
        /** Example output settings */
        examples: z.ZodDefault<z.ZodObject<{
            /** Include full (non-truncated) examples */
            full: z.ZodDefault<z.ZodBoolean>;
            /** Maximum example length in characters */
            maxLength: z.ZodDefault<z.ZodNumber>;
            /** Maximum examples per tool */
            maxPerTool: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            maxLength: number;
            full: boolean;
            maxPerTool: number;
        }, {
            maxLength?: number | undefined;
            full?: boolean | undefined;
            maxPerTool?: number | undefined;
        }>>;
        /** Output file names */
        files: z.ZodDefault<z.ZodObject<{
            /** Check report JSON file name */
            checkReport: z.ZodDefault<z.ZodString>;
            /** Explore report JSON file name */
            exploreReport: z.ZodDefault<z.ZodString>;
            /** Contract documentation file name */
            contractDoc: z.ZodDefault<z.ZodString>;
            /** Agents documentation file name */
            agentsDoc: z.ZodDefault<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            checkReport: string;
            exploreReport: string;
            contractDoc: string;
            agentsDoc: string;
        }, {
            checkReport?: string | undefined;
            exploreReport?: string | undefined;
            contractDoc?: string | undefined;
            agentsDoc?: string | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        format: "json" | "both" | "docs";
        examples: {
            maxLength: number;
            full: boolean;
            maxPerTool: number;
        };
        dir: string;
        files: {
            checkReport: string;
            exploreReport: string;
            contractDoc: string;
            agentsDoc: string;
        };
        docsDir: string;
    }, {
        format?: unknown;
        examples?: {
            maxLength?: number | undefined;
            full?: boolean | undefined;
            maxPerTool?: number | undefined;
        } | undefined;
        dir?: string | undefined;
        files?: {
            checkReport?: string | undefined;
            exploreReport?: string | undefined;
            contractDoc?: string | undefined;
            agentsDoc?: string | undefined;
        } | undefined;
        docsDir?: string | undefined;
    }>>;
    /** Baseline comparison (used by check command) */
    baseline: z.ZodDefault<z.ZodObject<{
        /** Default baseline file path (relative to output.dir or absolute) */
        path: z.ZodDefault<z.ZodString>;
        /** Path to save baseline after check (enables auto-save) */
        savePath: z.ZodOptional<z.ZodString>;
        /** Path to baseline for comparison (drift detection) */
        comparePath: z.ZodOptional<z.ZodString>;
        /** Fail if drift is detected */
        failOnDrift: z.ZodDefault<z.ZodBoolean>;
        /** Default output format for baseline comparisons */
        outputFormat: z.ZodDefault<z.ZodEnum<["text", "json", "markdown", "compact"]>>;
        /** Severity thresholds for filtering and CI failure */
        severity: z.ZodDefault<z.ZodObject<{
            /** Minimum severity level to include in reports */
            minimumSeverity: z.ZodDefault<z.ZodEnum<["none", "info", "warning", "breaking"]>>;
            /** Severity level at which to fail CI checks */
            failOnSeverity: z.ZodDefault<z.ZodEnum<["none", "info", "warning", "breaking"]>>;
            /** Suppress warning-level changes from output */
            suppressWarnings: z.ZodDefault<z.ZodBoolean>;
            /** Custom severity overrides per aspect */
            aspectOverrides: z.ZodOptional<z.ZodRecord<z.ZodEnum<["response_format", "response_structure", "response_schema_evolution", "error_handling", "error_pattern", "security", "performance", "schema", "description", "prompt", "resource", "server", "capability"]>, z.ZodEnum<["none", "info", "warning", "breaking"]>>>;
        }, "strip", z.ZodTypeAny, {
            minimumSeverity: "none" | "info" | "warning" | "breaking";
            failOnSeverity: "none" | "info" | "warning" | "breaking";
            suppressWarnings: boolean;
            aspectOverrides?: Partial<Record<"error_handling" | "resource" | "server" | "security" | "response_format" | "response_structure" | "response_schema_evolution" | "error_pattern" | "performance" | "schema" | "description" | "prompt" | "capability", "none" | "info" | "warning" | "breaking">> | undefined;
        }, {
            minimumSeverity?: "none" | "info" | "warning" | "breaking" | undefined;
            failOnSeverity?: "none" | "info" | "warning" | "breaking" | undefined;
            suppressWarnings?: boolean | undefined;
            aspectOverrides?: Partial<Record<"error_handling" | "resource" | "server" | "security" | "response_format" | "response_structure" | "response_schema_evolution" | "error_pattern" | "performance" | "schema" | "description" | "prompt" | "capability", "none" | "info" | "warning" | "breaking">> | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        severity: {
            minimumSeverity: "none" | "info" | "warning" | "breaking";
            failOnSeverity: "none" | "info" | "warning" | "breaking";
            suppressWarnings: boolean;
            aspectOverrides?: Partial<Record<"error_handling" | "resource" | "server" | "security" | "response_format" | "response_structure" | "response_schema_evolution" | "error_pattern" | "performance" | "schema" | "description" | "prompt" | "capability", "none" | "info" | "warning" | "breaking">> | undefined;
        };
        path: string;
        failOnDrift: boolean;
        outputFormat: "text" | "json" | "markdown" | "compact";
        savePath?: string | undefined;
        comparePath?: string | undefined;
    }, {
        severity?: {
            minimumSeverity?: "none" | "info" | "warning" | "breaking" | undefined;
            failOnSeverity?: "none" | "info" | "warning" | "breaking" | undefined;
            suppressWarnings?: boolean | undefined;
            aspectOverrides?: Partial<Record<"error_handling" | "resource" | "server" | "security" | "response_format" | "response_structure" | "response_schema_evolution" | "error_pattern" | "performance" | "schema" | "description" | "prompt" | "capability", "none" | "info" | "warning" | "breaking">> | undefined;
        } | undefined;
        path?: string | undefined;
        savePath?: string | undefined;
        comparePath?: string | undefined;
        failOnDrift?: boolean | undefined;
        outputFormat?: "text" | "json" | "markdown" | "compact" | undefined;
    }>>;
    /** Watch mode settings (used by watch command) */
    watch: z.ZodDefault<z.ZodObject<{
        /** Path to watch for changes */
        path: z.ZodDefault<z.ZodString>;
        /** Polling interval in milliseconds */
        interval: z.ZodDefault<z.ZodNumber>;
        /** File extensions to watch */
        extensions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        /** Command to run when drift is detected */
        onDrift: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        path: string;
        interval: number;
        extensions: string[];
        onDrift?: string | undefined;
    }, {
        path?: string | undefined;
        interval?: number | undefined;
        extensions?: string[] | undefined;
        onDrift?: string | undefined;
    }>>;
    /** Caching (used by both commands) */
    cache: z.ZodDefault<z.ZodObject<{
        /** Enable response caching */
        enabled: z.ZodDefault<z.ZodBoolean>;
        /** Cache directory */
        dir: z.ZodDefault<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        enabled: boolean;
        dir: string;
    }, {
        enabled?: boolean | undefined;
        dir?: string | undefined;
    }>>;
    /** Logging (used by both commands) */
    logging: z.ZodDefault<z.ZodObject<{
        /** Log level */
        level: z.ZodDefault<z.ZodEnum<["debug", "info", "warn", "error", "silent"]>>;
        /** Verbose output */
        verbose: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        level: "info" | "error" | "debug" | "warn" | "silent";
        verbose: boolean;
    }, {
        level?: "info" | "error" | "debug" | "warn" | "silent" | undefined;
        verbose?: boolean | undefined;
    }>>;
    /** Discovery defaults (used by discover command) */
    discovery: z.ZodDefault<z.ZodObject<{
        /** Output as JSON */
        json: z.ZodDefault<z.ZodBoolean>;
        /** Connection timeout in ms */
        timeout: z.ZodDefault<z.ZodNumber>;
        /** Transport type */
        transport: z.ZodDefault<z.ZodEnum<["stdio", "sse", "streamable-http"]>>;
        /** Remote MCP server URL */
        url: z.ZodDefault<z.ZodOptional<z.ZodString>>;
        /** Session ID for remote auth */
        sessionId: z.ZodDefault<z.ZodOptional<z.ZodString>>;
        /** Custom headers for remote server authentication */
        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, "strip", z.ZodTypeAny, {
        transport: "stdio" | "sse" | "streamable-http";
        timeout: number;
        sessionId: string;
        url: string;
        json: boolean;
        headers?: Record<string, string> | undefined;
    }, {
        transport?: "stdio" | "sse" | "streamable-http" | undefined;
        timeout?: number | undefined;
        sessionId?: string | undefined;
        headers?: Record<string, string> | undefined;
        url?: string | undefined;
        json?: boolean | undefined;
    }>>;
    /** Registry defaults (used by registry command) */
    registry: z.ZodDefault<z.ZodObject<{
        /** Maximum results to show */
        limit: z.ZodDefault<z.ZodNumber>;
        /** Output as JSON */
        json: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        json: boolean;
        limit: number;
    }, {
        json?: boolean | undefined;
        limit?: number | undefined;
    }>>;
    /** Golden command defaults */
    golden: z.ZodDefault<z.ZodObject<{
        /** Default JSON args for golden save */
        defaultArgs: z.ZodDefault<z.ZodString>;
        /** Default comparison mode for golden save */
        mode: z.ZodDefault<z.ZodEnum<["exact", "structural", "semantic"]>>;
        /** Output format for compare */
        compareFormat: z.ZodDefault<z.ZodEnum<["text", "json", "markdown"]>>;
        /** Output format for list */
        listFormat: z.ZodDefault<z.ZodEnum<["text", "json"]>>;
        /** Normalize timestamps by default */
        normalizeTimestamps: z.ZodDefault<z.ZodBoolean>;
        /** Normalize UUIDs by default */
        normalizeUuids: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        mode: "structural" | "exact" | "semantic";
        defaultArgs: string;
        compareFormat: "text" | "json" | "markdown";
        listFormat: "text" | "json";
        normalizeTimestamps: boolean;
        normalizeUuids: boolean;
    }, {
        mode?: "structural" | "exact" | "semantic" | undefined;
        defaultArgs?: string | undefined;
        compareFormat?: "text" | "json" | "markdown" | undefined;
        listFormat?: "text" | "json" | undefined;
        normalizeTimestamps?: boolean | undefined;
        normalizeUuids?: boolean | undefined;
    }>>;
    /** Contract command defaults */
    contract: z.ZodDefault<z.ZodObject<{
        /** Default contract file path */
        path: z.ZodOptional<z.ZodString>;
        /** Validation mode */
        mode: z.ZodDefault<z.ZodEnum<["strict", "lenient", "report"]>>;
        /** Output format */
        format: z.ZodDefault<z.ZodEnum<["text", "json", "markdown"]>>;
        /** Server startup timeout */
        timeout: z.ZodDefault<z.ZodNumber>;
        /** Exit with error when violations are found */
        failOnViolation: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        mode: "strict" | "lenient" | "report";
        format: "text" | "json" | "markdown";
        timeout: number;
        failOnViolation: boolean;
        path?: string | undefined;
    }, {
        mode?: "strict" | "lenient" | "report" | undefined;
        format?: "text" | "json" | "markdown" | undefined;
        timeout?: number | undefined;
        path?: string | undefined;
        failOnViolation?: boolean | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    server: {
        command: string;
        args: string[];
        transport: "stdio" | "sse" | "streamable-http";
        timeout: number;
        sessionId: string;
        url: string;
        headers?: Record<string, string> | undefined;
        env?: Record<string, string> | undefined;
    };
    discovery: {
        transport: "stdio" | "sse" | "streamable-http";
        timeout: number;
        sessionId: string;
        url: string;
        json: boolean;
        headers?: Record<string, string> | undefined;
    };
    check: {
        security: {
            enabled: boolean;
            categories: ("sql_injection" | "xss" | "path_traversal" | "command_injection" | "ssrf" | "error_disclosure")[];
        };
        warmupRuns: number;
        externalServices: {
            mode: "skip" | "mock" | "fail";
            services?: Record<string, {
                enabled?: boolean | undefined;
                sandboxCredentials?: Record<string, string> | undefined;
            }> | undefined;
        };
        assertions: {
            strict: boolean;
            enabled: boolean;
            infer: boolean;
        };
        rateLimit: {
            maxRetries: number;
            enabled: boolean;
            backoffStrategy: "linear" | "exponential";
            requestsPerSecond: number;
            burstLimit: number;
        };
        statefulTesting: {
            enabled: boolean;
            maxChainLength: number;
            shareOutputsBetweenTools: boolean;
        };
        parallel: boolean;
        incremental: boolean;
        incrementalCacheHours: number;
        parallelWorkers: number;
        performanceThreshold: number;
        diffFormat: "text" | "json" | "markdown" | "github" | "compact" | "junit" | "sarif";
        smartTestValues: boolean;
        metrics: {
            countValidationAsSuccess: boolean;
            separateValidationMetrics: boolean;
        };
        sampling: {
            minSamples: number;
            targetConfidence: "high" | "low" | "medium";
            failOnLowConfidence: boolean;
        };
        testFixtures?: {
            patterns?: {
                match: string;
                value?: unknown;
            }[] | undefined;
            parameterValues?: Record<string, unknown> | undefined;
        } | undefined;
    };
    explore: {
        maxQuestionsPerTool: number;
        skipErrorTests: boolean;
        personas: ("technical_writer" | "security_tester" | "qa_engineer" | "novice_user")[];
        parallelPersonas: boolean;
        personaConcurrency: number;
    };
    output: {
        format: "json" | "both" | "docs";
        examples: {
            maxLength: number;
            full: boolean;
            maxPerTool: number;
        };
        dir: string;
        files: {
            checkReport: string;
            exploreReport: string;
            contractDoc: string;
            agentsDoc: string;
        };
        docsDir: string;
    };
    cache: {
        enabled: boolean;
        dir: string;
    };
    workflows: {
        timeouts: {
            probeTool: number;
            toolCall: number;
            stateSnapshot: number;
            llmAnalysis: number;
            llmSummary: number;
        };
        stepTimeout: number;
        requireSuccessfulDependencies: boolean;
        discover: boolean;
        trackState: boolean;
        autoGenerate: boolean;
        path?: string | undefined;
    };
    llm: {
        provider: "openai" | "anthropic" | "ollama";
        model: string;
        ollama: {
            baseUrl: string;
        };
        openaiApiKeyEnvVar?: string | undefined;
        anthropicApiKeyEnvVar?: string | undefined;
    };
    scenarios: {
        only: boolean;
        path?: string | undefined;
    };
    baseline: {
        severity: {
            minimumSeverity: "none" | "info" | "warning" | "breaking";
            failOnSeverity: "none" | "info" | "warning" | "breaking";
            suppressWarnings: boolean;
            aspectOverrides?: Partial<Record<"error_handling" | "resource" | "server" | "security" | "response_format" | "response_structure" | "response_schema_evolution" | "error_pattern" | "performance" | "schema" | "description" | "prompt" | "capability", "none" | "info" | "warning" | "breaking">> | undefined;
        };
        path: string;
        failOnDrift: boolean;
        outputFormat: "text" | "json" | "markdown" | "compact";
        savePath?: string | undefined;
        comparePath?: string | undefined;
    };
    watch: {
        path: string;
        interval: number;
        extensions: string[];
        onDrift?: string | undefined;
    };
    logging: {
        level: "info" | "error" | "debug" | "warn" | "silent";
        verbose: boolean;
    };
    registry: {
        json: boolean;
        limit: number;
    };
    golden: {
        mode: "structural" | "exact" | "semantic";
        defaultArgs: string;
        compareFormat: "text" | "json" | "markdown";
        listFormat: "text" | "json";
        normalizeTimestamps: boolean;
        normalizeUuids: boolean;
    };
    contract: {
        mode: "strict" | "lenient" | "report";
        format: "text" | "json" | "markdown";
        timeout: number;
        failOnViolation: boolean;
        path?: string | undefined;
    };
}, {
    server?: {
        command?: string | undefined;
        args?: string[] | undefined;
        transport?: "stdio" | "sse" | "streamable-http" | undefined;
        timeout?: number | undefined;
        sessionId?: string | undefined;
        headers?: Record<string, string> | undefined;
        url?: string | undefined;
        env?: Record<string, string> | undefined;
    } | undefined;
    discovery?: {
        transport?: "stdio" | "sse" | "streamable-http" | undefined;
        timeout?: number | undefined;
        sessionId?: string | undefined;
        headers?: Record<string, string> | undefined;
        url?: string | undefined;
        json?: boolean | undefined;
    } | undefined;
    check?: {
        security?: {
            enabled?: boolean | undefined;
            categories?: ("sql_injection" | "xss" | "path_traversal" | "command_injection" | "ssrf" | "error_disclosure")[] | undefined;
        } | undefined;
        warmupRuns?: number | undefined;
        externalServices?: {
            mode?: "skip" | "mock" | "fail" | undefined;
            services?: Record<string, {
                enabled?: boolean | undefined;
                sandboxCredentials?: Record<string, string> | undefined;
            }> | undefined;
        } | undefined;
        assertions?: {
            strict?: boolean | undefined;
            enabled?: boolean | undefined;
            infer?: boolean | undefined;
        } | undefined;
        rateLimit?: {
            maxRetries?: number | undefined;
            enabled?: boolean | undefined;
            backoffStrategy?: "linear" | "exponential" | undefined;
            requestsPerSecond?: number | undefined;
            burstLimit?: number | undefined;
        } | undefined;
        statefulTesting?: {
            enabled?: boolean | undefined;
            maxChainLength?: number | undefined;
            shareOutputsBetweenTools?: boolean | undefined;
        } | undefined;
        testFixtures?: {
            patterns?: {
                match: string;
                value?: unknown;
            }[] | undefined;
            parameterValues?: Record<string, unknown> | undefined;
        } | undefined;
        parallel?: boolean | undefined;
        incremental?: boolean | undefined;
        incrementalCacheHours?: number | undefined;
        parallelWorkers?: number | undefined;
        performanceThreshold?: number | undefined;
        diffFormat?: "text" | "json" | "markdown" | "github" | "compact" | "junit" | "sarif" | undefined;
        smartTestValues?: boolean | undefined;
        metrics?: {
            countValidationAsSuccess?: boolean | undefined;
            separateValidationMetrics?: boolean | undefined;
        } | undefined;
        sampling?: {
            minSamples?: number | undefined;
            targetConfidence?: "high" | "low" | "medium" | undefined;
            failOnLowConfidence?: boolean | undefined;
        } | undefined;
    } | undefined;
    explore?: {
        maxQuestionsPerTool?: number | undefined;
        skipErrorTests?: boolean | undefined;
        personas?: ("technical_writer" | "security_tester" | "qa_engineer" | "novice_user")[] | undefined;
        parallelPersonas?: boolean | undefined;
        personaConcurrency?: number | undefined;
    } | undefined;
    output?: {
        format?: unknown;
        examples?: {
            maxLength?: number | undefined;
            full?: boolean | undefined;
            maxPerTool?: number | undefined;
        } | undefined;
        dir?: string | undefined;
        files?: {
            checkReport?: string | undefined;
            exploreReport?: string | undefined;
            contractDoc?: string | undefined;
            agentsDoc?: string | undefined;
        } | undefined;
        docsDir?: string | undefined;
    } | undefined;
    cache?: {
        enabled?: boolean | undefined;
        dir?: string | undefined;
    } | undefined;
    workflows?: {
        path?: string | undefined;
        timeouts?: {
            probeTool?: number | undefined;
            toolCall?: number | undefined;
            stateSnapshot?: number | undefined;
            llmAnalysis?: number | undefined;
            llmSummary?: number | undefined;
        } | undefined;
        stepTimeout?: number | undefined;
        requireSuccessfulDependencies?: boolean | undefined;
        discover?: boolean | undefined;
        trackState?: boolean | undefined;
        autoGenerate?: boolean | undefined;
    } | undefined;
    llm?: {
        provider?: "openai" | "anthropic" | "ollama" | undefined;
        model?: string | undefined;
        ollama?: {
            baseUrl?: string | undefined;
        } | undefined;
        openaiApiKeyEnvVar?: string | undefined;
        anthropicApiKeyEnvVar?: string | undefined;
    } | undefined;
    scenarios?: {
        path?: string | undefined;
        only?: boolean | undefined;
    } | undefined;
    baseline?: {
        severity?: {
            minimumSeverity?: "none" | "info" | "warning" | "breaking" | undefined;
            failOnSeverity?: "none" | "info" | "warning" | "breaking" | undefined;
            suppressWarnings?: boolean | undefined;
            aspectOverrides?: Partial<Record<"error_handling" | "resource" | "server" | "security" | "response_format" | "response_structure" | "response_schema_evolution" | "error_pattern" | "performance" | "schema" | "description" | "prompt" | "capability", "none" | "info" | "warning" | "breaking">> | undefined;
        } | undefined;
        path?: string | undefined;
        savePath?: string | undefined;
        comparePath?: string | undefined;
        failOnDrift?: boolean | undefined;
        outputFormat?: "text" | "json" | "markdown" | "compact" | undefined;
    } | undefined;
    watch?: {
        path?: string | undefined;
        interval?: number | undefined;
        extensions?: string[] | undefined;
        onDrift?: string | undefined;
    } | undefined;
    logging?: {
        level?: "info" | "error" | "debug" | "warn" | "silent" | undefined;
        verbose?: boolean | undefined;
    } | undefined;
    registry?: {
        json?: boolean | undefined;
        limit?: number | undefined;
    } | undefined;
    golden?: {
        mode?: "structural" | "exact" | "semantic" | undefined;
        defaultArgs?: string | undefined;
        compareFormat?: "text" | "json" | "markdown" | undefined;
        listFormat?: "text" | "json" | undefined;
        normalizeTimestamps?: boolean | undefined;
        normalizeUuids?: boolean | undefined;
    } | undefined;
    contract?: {
        mode?: "strict" | "lenient" | "report" | undefined;
        format?: "text" | "json" | "markdown" | undefined;
        timeout?: number | undefined;
        path?: string | undefined;
        failOnViolation?: boolean | undefined;
    } | undefined;
}>;
/**
 * Inferred TypeScript type from the schema.
 */
export type BellwetherConfig = z.infer<typeof bellwetherConfigSchema>;
/**
 * Validate a configuration object.
 * Returns the validated config with defaults applied, or throws with helpful errors.
 */
export declare function validateConfig(config: unknown, filePath?: string): BellwetherConfig;
/**
 * Generate configuration warnings for potentially problematic settings.
 */
export declare function getConfigWarnings(config: BellwetherConfig): string[];
/**
 * Validate that required fields are present for the check command.
 */
export declare function validateConfigForCheck(config: BellwetherConfig, serverCommand?: string): void;
/**
 * Validate that required fields are present for the explore command.
 */
export declare function validateConfigForExplore(config: BellwetherConfig, serverCommand?: string): void;
/**
 * Check if a config file exists at the given path or in common locations.
 */
export declare function findConfigFile(explicitPath?: string): string | null;
//# sourceMappingURL=validator.d.ts.map