import { z } from 'zod';
export declare const DefaultOutputSchema: z.ZodObject<{
    ok: z.ZodBoolean;
    result: z.ZodOptional<z.ZodUnknown>;
    error: z.ZodOptional<z.ZodObject<{
        code: z.ZodString;
        message: z.ZodString;
        retryable: z.ZodOptional<z.ZodBoolean>;
        kind: z.ZodOptional<z.ZodEnum<{
            validation: "validation";
            budget: "budget";
            upstream: "upstream";
            timeout: "timeout";
            cancelled: "cancelled";
            internal: "internal";
            busy: "busy";
        }>>;
    }, z.core.$strict>>;
}, z.core.$strict>;
/**
 * Create a typed outputSchema for an MCP tool by wrapping its resultSchema
 * in the standard ok/error envelope.
 */
export declare function createToolOutputSchema(resultSchema: z.ZodType): z.ZodType;
export declare const PrImpactResultSchema: z.ZodObject<{
    severity: z.ZodEnum<{
        medium: "medium";
        high: "high";
        low: "low";
        critical: "critical";
    }>;
    categories: z.ZodArray<z.ZodEnum<{
        breaking_change: "breaking_change";
        api_change: "api_change";
        schema_change: "schema_change";
        config_change: "config_change";
        dependency_update: "dependency_update";
        security_fix: "security_fix";
        deprecation: "deprecation";
        performance_change: "performance_change";
        bug_fix: "bug_fix";
        feature_addition: "feature_addition";
    }>>;
    summary: z.ZodString;
    breakingChanges: z.ZodArray<z.ZodString>;
    affectedAreas: z.ZodArray<z.ZodString>;
    rollbackComplexity: z.ZodEnum<{
        trivial: "trivial";
        moderate: "moderate";
        complex: "complex";
        irreversible: "irreversible";
    }>;
}, z.core.$strict>;
export declare const ReviewSummaryGeminiResultSchema: z.ZodObject<{
    summary: z.ZodString;
    overallRisk: z.ZodEnum<{
        medium: "medium";
        high: "high";
        low: "low";
    }>;
    keyChanges: z.ZodArray<z.ZodString>;
    recommendation: z.ZodString;
}, z.core.$strict>;
export declare const ReviewSummaryResultSchema: z.ZodObject<{
    summary: z.ZodString;
    overallRisk: z.ZodEnum<{
        medium: "medium";
        high: "high";
        low: "low";
    }>;
    keyChanges: z.ZodArray<z.ZodString>;
    recommendation: z.ZodString;
    stats: z.ZodObject<{
        filesChanged: z.ZodInt;
        linesAdded: z.ZodInt;
        linesRemoved: z.ZodInt;
    }, z.core.$strict>;
}, z.core.$strict>;
declare const TestCaseSchema: z.ZodObject<{
    name: z.ZodString;
    type: z.ZodEnum<{
        unit: "unit";
        integration: "integration";
        e2e: "e2e";
        regression: "regression";
        security: "security";
        performance: "performance";
    }>;
    file: z.ZodString;
    description: z.ZodString;
    pseudoCode: z.ZodString;
    priority: z.ZodEnum<{
        must_have: "must_have";
        should_have: "should_have";
        nice_to_have: "nice_to_have";
    }>;
}, z.core.$strict>;
export declare const TestPlanResultSchema: z.ZodObject<{
    summary: z.ZodString;
    testCases: z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        type: z.ZodEnum<{
            unit: "unit";
            integration: "integration";
            e2e: "e2e";
            regression: "regression";
            security: "security";
            performance: "performance";
        }>;
        file: z.ZodString;
        description: z.ZodString;
        pseudoCode: z.ZodString;
        priority: z.ZodEnum<{
            must_have: "must_have";
            should_have: "should_have";
            nice_to_have: "nice_to_have";
        }>;
    }, z.core.$strict>>;
    coverageSummary: z.ZodString;
}, z.core.$strict>;
export declare const AnalyzeComplexityResultSchema: z.ZodObject<{
    timeComplexity: z.ZodString;
    spaceComplexity: z.ZodString;
    explanation: z.ZodString;
    potentialBottlenecks: z.ZodArray<z.ZodString>;
    isDegradation: z.ZodBoolean;
}, z.core.$strict>;
export declare const DetectApiBreakingResultSchema: z.ZodObject<{
    hasBreakingChanges: z.ZodBoolean;
    breakingChanges: z.ZodArray<z.ZodObject<{
        element: z.ZodString;
        natureOfChange: z.ZodString;
        consumerImpact: z.ZodString;
        suggestedMitigation: z.ZodString;
    }, z.core.$strict>>;
}, z.core.$strict>;
declare const RefactorSuggestionSchema: z.ZodObject<{
    category: z.ZodEnum<{
        naming: "naming";
        complexity: "complexity";
        duplication: "duplication";
        grouping: "grouping";
    }>;
    target: z.ZodString;
    currentIssue: z.ZodString;
    suggestion: z.ZodString;
    priority: z.ZodEnum<{
        medium: "medium";
        high: "high";
        low: "low";
    }>;
}, z.core.$strict>;
export declare const RefactorCodeGeminiResultSchema: z.ZodObject<{
    summary: z.ZodString;
    suggestions: z.ZodArray<z.ZodObject<{
        category: z.ZodEnum<{
            naming: "naming";
            complexity: "complexity";
            duplication: "duplication";
            grouping: "grouping";
        }>;
        target: z.ZodString;
        currentIssue: z.ZodString;
        suggestion: z.ZodString;
        priority: z.ZodEnum<{
            medium: "medium";
            high: "high";
            low: "low";
        }>;
    }, z.core.$strict>>;
}, z.core.$strict>;
export declare const RefactorCodeResultSchema: z.ZodObject<{
    summary: z.ZodString;
    suggestions: z.ZodArray<z.ZodObject<{
        category: z.ZodEnum<{
            naming: "naming";
            complexity: "complexity";
            duplication: "duplication";
            grouping: "grouping";
        }>;
        target: z.ZodString;
        currentIssue: z.ZodString;
        suggestion: z.ZodString;
        priority: z.ZodEnum<{
            medium: "medium";
            high: "high";
            low: "low";
        }>;
    }, z.core.$strict>>;
    filePath: z.ZodString;
    language: z.ZodString;
    namingIssuesCount: z.ZodInt;
    complexityIssuesCount: z.ZodInt;
    duplicationIssuesCount: z.ZodInt;
    groupingIssuesCount: z.ZodInt;
}, z.core.$strict>;
export type DefaultOutput = z.infer<typeof DefaultOutputSchema>;
export type PrImpactResult = z.infer<typeof PrImpactResultSchema>;
export type ReviewSummaryGeminiResult = z.infer<typeof ReviewSummaryGeminiResultSchema>;
export type ReviewSummaryResult = z.infer<typeof ReviewSummaryResultSchema>;
export type TestCase = z.infer<typeof TestCaseSchema>;
export type TestPlanResult = z.infer<typeof TestPlanResultSchema>;
export type AnalyzeComplexityResult = z.infer<typeof AnalyzeComplexityResultSchema>;
export type DetectApiBreakingResult = z.infer<typeof DetectApiBreakingResultSchema>;
export type RefactorSuggestion = z.infer<typeof RefactorSuggestionSchema>;
export type RefactorCodeGeminiResult = z.infer<typeof RefactorCodeGeminiResultSchema>;
export type RefactorCodeResult = z.infer<typeof RefactorCodeResultSchema>;
declare const AskCodeReferenceSchema: z.ZodObject<{
    target: z.ZodString;
    explanation: z.ZodString;
}, z.core.$strict>;
export declare const AskGeminiResultSchema: z.ZodObject<{
    answer: z.ZodString;
    codeReferences: z.ZodArray<z.ZodObject<{
        target: z.ZodString;
        explanation: z.ZodString;
    }, z.core.$strict>>;
    confidence: z.ZodEnum<{
        medium: "medium";
        high: "high";
        low: "low";
    }>;
}, z.core.$strict>;
export declare const AskResultSchema: z.ZodObject<{
    answer: z.ZodString;
    codeReferences: z.ZodArray<z.ZodObject<{
        target: z.ZodString;
        explanation: z.ZodString;
    }, z.core.$strict>>;
    confidence: z.ZodEnum<{
        medium: "medium";
        high: "high";
        low: "low";
    }>;
    filePath: z.ZodString;
    language: z.ZodString;
}, z.core.$strict>;
export type AskCodeReference = z.infer<typeof AskCodeReferenceSchema>;
export type AskGeminiResult = z.infer<typeof AskGeminiResultSchema>;
export type AskResult = z.infer<typeof AskResultSchema>;
export declare const VerifyLogicGeminiResultSchema: z.ZodObject<{
    answer: z.ZodString;
    verified: z.ZodBoolean;
    codeBlocks: z.ZodArray<z.ZodObject<{
        code: z.ZodString;
        language: z.ZodString;
    }, z.core.$strict>>;
    executionResults: z.ZodArray<z.ZodObject<{
        outcome: z.ZodEnum<{
            OUTCOME_OK: "OUTCOME_OK";
            OUTCOME_FAILED: "OUTCOME_FAILED";
            OUTCOME_DEADLINE_EXCEEDED: "OUTCOME_DEADLINE_EXCEEDED";
            OUTCOME_UNSPECIFIED: "OUTCOME_UNSPECIFIED";
        }>;
        output: z.ZodString;
    }, z.core.$strict>>;
}, z.core.$strict>;
export declare const VerifyLogicResultSchema: z.ZodObject<{
    answer: z.ZodString;
    verified: z.ZodBoolean;
    codeBlocks: z.ZodArray<z.ZodObject<{
        code: z.ZodString;
        language: z.ZodString;
    }, z.core.$strict>>;
    executionResults: z.ZodArray<z.ZodObject<{
        outcome: z.ZodEnum<{
            OUTCOME_OK: "OUTCOME_OK";
            OUTCOME_FAILED: "OUTCOME_FAILED";
            OUTCOME_DEADLINE_EXCEEDED: "OUTCOME_DEADLINE_EXCEEDED";
            OUTCOME_UNSPECIFIED: "OUTCOME_UNSPECIFIED";
        }>;
        output: z.ZodString;
    }, z.core.$strict>>;
    filePath: z.ZodString;
    language: z.ZodString;
}, z.core.$strict>;
export type VerifyLogicGeminiResult = z.infer<typeof VerifyLogicGeminiResultSchema>;
export type VerifyLogicResult = z.infer<typeof VerifyLogicResultSchema>;
declare const DocBlockSchema: z.ZodObject<{
    target: z.ZodString;
    kind: z.ZodEnum<{
        function: "function";
        method: "method";
        type: "type";
        enum: "enum";
        class: "class";
        interface: "interface";
        constant: "constant";
        variable: "variable";
    }>;
    signature: z.ZodString;
    documentation: z.ZodString;
    example: z.ZodOptional<z.ZodString>;
}, z.core.$strict>;
export declare const GenerateDocumentationGeminiResultSchema: z.ZodObject<{
    summary: z.ZodString;
    docBlocks: z.ZodArray<z.ZodObject<{
        target: z.ZodString;
        kind: z.ZodEnum<{
            function: "function";
            method: "method";
            type: "type";
            enum: "enum";
            class: "class";
            interface: "interface";
            constant: "constant";
            variable: "variable";
        }>;
        signature: z.ZodString;
        documentation: z.ZodString;
        example: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>;
    totalExports: z.ZodInt;
}, z.core.$strict>;
export declare const GenerateDocumentationResultSchema: z.ZodObject<{
    summary: z.ZodString;
    docBlocks: z.ZodArray<z.ZodObject<{
        target: z.ZodString;
        kind: z.ZodEnum<{
            function: "function";
            method: "method";
            type: "type";
            enum: "enum";
            class: "class";
            interface: "interface";
            constant: "constant";
            variable: "variable";
        }>;
        signature: z.ZodString;
        documentation: z.ZodString;
        example: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>;
    totalExports: z.ZodInt;
    filePath: z.ZodString;
    language: z.ZodString;
    documentedCount: z.ZodInt;
}, z.core.$strict>;
export type DocBlock = z.infer<typeof DocBlockSchema>;
export type GenerateDocumentationGeminiResult = z.infer<typeof GenerateDocumentationGeminiResultSchema>;
export type GenerateDocumentationResult = z.infer<typeof GenerateDocumentationResultSchema>;
declare const CodeSmellSchema: z.ZodObject<{
    type: z.ZodEnum<{
        dead_code: "dead_code";
        magic_number: "magic_number";
        long_function: "long_function";
        deep_nesting: "deep_nesting";
        god_class: "god_class";
        feature_envy: "feature_envy";
        primitive_obsession: "primitive_obsession";
        shotgun_surgery: "shotgun_surgery";
        data_clump: "data_clump";
        long_parameter_list: "long_parameter_list";
    }>;
    target: z.ZodString;
    severity: z.ZodEnum<{
        error: "error";
        info: "info";
        warning: "warning";
    }>;
    explanation: z.ZodString;
    suggestion: z.ZodString;
}, z.core.$strict>;
export declare const DetectCodeSmellsGeminiResultSchema: z.ZodObject<{
    summary: z.ZodString;
    smells: z.ZodArray<z.ZodObject<{
        type: z.ZodEnum<{
            dead_code: "dead_code";
            magic_number: "magic_number";
            long_function: "long_function";
            deep_nesting: "deep_nesting";
            god_class: "god_class";
            feature_envy: "feature_envy";
            primitive_obsession: "primitive_obsession";
            shotgun_surgery: "shotgun_surgery";
            data_clump: "data_clump";
            long_parameter_list: "long_parameter_list";
        }>;
        target: z.ZodString;
        severity: z.ZodEnum<{
            error: "error";
            info: "info";
            warning: "warning";
        }>;
        explanation: z.ZodString;
        suggestion: z.ZodString;
    }, z.core.$strict>>;
    overallHealth: z.ZodEnum<{
        healthy: "healthy";
        needs_attention: "needs_attention";
        unhealthy: "unhealthy";
    }>;
}, z.core.$strict>;
export declare const DetectCodeSmellsResultSchema: z.ZodObject<{
    summary: z.ZodString;
    smells: z.ZodArray<z.ZodObject<{
        type: z.ZodEnum<{
            dead_code: "dead_code";
            magic_number: "magic_number";
            long_function: "long_function";
            deep_nesting: "deep_nesting";
            god_class: "god_class";
            feature_envy: "feature_envy";
            primitive_obsession: "primitive_obsession";
            shotgun_surgery: "shotgun_surgery";
            data_clump: "data_clump";
            long_parameter_list: "long_parameter_list";
        }>;
        target: z.ZodString;
        severity: z.ZodEnum<{
            error: "error";
            info: "info";
            warning: "warning";
        }>;
        explanation: z.ZodString;
        suggestion: z.ZodString;
    }, z.core.$strict>>;
    overallHealth: z.ZodEnum<{
        healthy: "healthy";
        needs_attention: "needs_attention";
        unhealthy: "unhealthy";
    }>;
    filePath: z.ZodString;
    language: z.ZodString;
    infoCount: z.ZodInt;
    warningCount: z.ZodInt;
    errorCount: z.ZodInt;
}, z.core.$strict>;
export type CodeSmell = z.infer<typeof CodeSmellSchema>;
export type DetectCodeSmellsGeminiResult = z.infer<typeof DetectCodeSmellsGeminiResultSchema>;
export type DetectCodeSmellsResult = z.infer<typeof DetectCodeSmellsResultSchema>;
export declare const WebSearchResultSchema: z.ZodObject<{
    text: z.ZodString;
    groundingMetadata: z.ZodUnknown;
}, z.core.$strict>;
export type WebSearchResult = z.infer<typeof WebSearchResultSchema>;
export declare const GenerateDiffResultSchema: z.ZodObject<{
    diffRef: z.ZodString;
    diffHash: z.ZodString;
    stats: z.ZodObject<{
        files: z.ZodInt;
        added: z.ZodInt;
        deleted: z.ZodInt;
    }, z.core.$strict>;
    generatedAt: z.ZodString;
    mode: z.ZodEnum<{
        unstaged: "unstaged";
        staged: "staged";
    }>;
    repository: z.ZodString;
    message: z.ZodString;
    elapsedMs: z.ZodInt;
}, z.core.$strict>;
export declare const LoadFileResultSchema: z.ZodObject<{
    fileRef: z.ZodString;
    filePath: z.ZodString;
    language: z.ZodString;
    lineCount: z.ZodInt;
    sizeChars: z.ZodInt;
    cachedAt: z.ZodNumber;
    message: z.ZodString;
}, z.core.$strict>;
export type GenerateDiffResult = z.infer<typeof GenerateDiffResultSchema>;
export type LoadFileResult = z.infer<typeof LoadFileResultSchema>;
export {};