@task-shepherd/agent 1.0.2

package/mcp-agent/dist/types.d.ts

@@ -0,0 +1,1893 @@
+import { z } from 'zod';
+export declare const AnalysisStrengthSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodString;
+    impact: z.ZodEnum<["low", "medium", "high"]>;
+    evidence: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    description: string;
+    impact: "low" | "medium" | "high";
+    evidence?: string[] | undefined;
+}, {
+    title: string;
+    description: string;
+    impact: "low" | "medium" | "high";
+    evidence?: string[] | undefined;
+}>;
+export declare const AnalysisWeaknessSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodString;
+    severity: z.ZodEnum<["low", "medium", "high"]>;
+    affected_areas: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    improvement_effort: z.ZodOptional<z.ZodEnum<["minimal", "moderate", "significant"]>>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    description: string;
+    severity: "low" | "medium" | "high";
+    affected_areas?: string[] | undefined;
+    improvement_effort?: "minimal" | "moderate" | "significant" | undefined;
+}, {
+    title: string;
+    description: string;
+    severity: "low" | "medium" | "high";
+    affected_areas?: string[] | undefined;
+    improvement_effort?: "minimal" | "moderate" | "significant" | undefined;
+}>;
+export declare const AnalysisRiskSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodString;
+    probability: z.ZodEnum<["low", "medium", "high"]>;
+    impact: z.ZodEnum<["low", "medium", "high"]>;
+    mitigation_strategy: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    description: string;
+    impact: "low" | "medium" | "high";
+    probability: "low" | "medium" | "high";
+    mitigation_strategy?: string | undefined;
+}, {
+    title: string;
+    description: string;
+    impact: "low" | "medium" | "high";
+    probability: "low" | "medium" | "high";
+    mitigation_strategy?: string | undefined;
+}>;
+export declare const AnalysisOpportunitySchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodString;
+    potential_value: z.ZodEnum<["low", "medium", "high"]>;
+    implementation_complexity: z.ZodOptional<z.ZodEnum<["simple", "moderate", "complex"]>>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    description: string;
+    potential_value: "low" | "medium" | "high";
+    implementation_complexity?: "moderate" | "simple" | "complex" | undefined;
+}, {
+    title: string;
+    description: string;
+    potential_value: "low" | "medium" | "high";
+    implementation_complexity?: "moderate" | "simple" | "complex" | undefined;
+}>;
+export declare const ScoreWithReasoningSchema: z.ZodObject<{
+    score: z.ZodNumber;
+    reasoning: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    score: number;
+    reasoning: string;
+}, {
+    score: number;
+    reasoning: string;
+}>;
+export declare const RecommendationSchema: z.ZodObject<{
+    id: z.ZodString;
+    category: z.ZodEnum<["requirements", "architecture", "security", "performance", "maintainability", "testing"]>;
+    title: z.ZodString;
+    description: z.ZodString;
+    implementation_guide: z.ZodOptional<z.ZodString>;
+    priority: z.ZodEnum<["low", "medium", "high", "critical"]>;
+    estimated_effort: z.ZodOptional<z.ZodString>;
+    business_impact: z.ZodOptional<z.ZodString>;
+    technical_complexity: z.ZodOptional<z.ZodEnum<["simple", "moderate", "complex"]>>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    description: string;
+    id: string;
+    category: "requirements" | "architecture" | "security" | "performance" | "maintainability" | "testing";
+    priority: "low" | "medium" | "high" | "critical";
+    implementation_guide?: string | undefined;
+    estimated_effort?: string | undefined;
+    business_impact?: string | undefined;
+    technical_complexity?: "moderate" | "simple" | "complex" | undefined;
+}, {
+    title: string;
+    description: string;
+    id: string;
+    category: "requirements" | "architecture" | "security" | "performance" | "maintainability" | "testing";
+    priority: "low" | "medium" | "high" | "critical";
+    implementation_guide?: string | undefined;
+    estimated_effort?: string | undefined;
+    business_impact?: string | undefined;
+    technical_complexity?: "moderate" | "simple" | "complex" | undefined;
+}>;
+export declare const ExplicitRequirementSchema: z.ZodObject<{
+    requirement: z.ZodString;
+    source_text: z.ZodString;
+    confidence: z.ZodEnum<["high", "medium", "low"]>;
+}, "strip", z.ZodTypeAny, {
+    requirement: string;
+    source_text: string;
+    confidence: "low" | "medium" | "high";
+}, {
+    requirement: string;
+    source_text: string;
+    confidence: "low" | "medium" | "high";
+}>;
+export declare const InferredRequirementSchema: z.ZodObject<{
+    requirement: z.ZodString;
+    rationale: z.ZodString;
+    domain_pattern: z.ZodString;
+    priority: z.ZodEnum<["critical", "high", "medium", "low"]>;
+}, "strip", z.ZodTypeAny, {
+    priority: "low" | "medium" | "high" | "critical";
+    requirement: string;
+    rationale: string;
+    domain_pattern: string;
+}, {
+    priority: "low" | "medium" | "high" | "critical";
+    requirement: string;
+    rationale: string;
+    domain_pattern: string;
+}>;
+export declare const NonFunctionalRequirementSchema: z.ZodObject<{
+    category: z.ZodString;
+    requirement: z.ZodString;
+    industry_standard: z.ZodBoolean;
+    customization_needed: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    category: string;
+    requirement: string;
+    industry_standard: boolean;
+    customization_needed: boolean;
+}, {
+    category: string;
+    requirement: string;
+    industry_standard: boolean;
+    customization_needed: boolean;
+}>;
+export declare const ClarificationQuestionSchema: z.ZodObject<{
+    category: z.ZodString;
+    question: z.ZodString;
+    impact_if_unclear: z.ZodString;
+    suggested_default: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    category: string;
+    question: string;
+    impact_if_unclear: string;
+    suggested_default: string;
+}, {
+    category: string;
+    question: string;
+    impact_if_unclear: string;
+    suggested_default: string;
+}>;
+export declare const SuggestedProductRequirementsSchema: z.ZodObject<{
+    explicit_requirements: z.ZodArray<z.ZodObject<{
+        requirement: z.ZodString;
+        source_text: z.ZodString;
+        confidence: z.ZodEnum<["high", "medium", "low"]>;
+    }, "strip", z.ZodTypeAny, {
+        requirement: string;
+        source_text: string;
+        confidence: "low" | "medium" | "high";
+    }, {
+        requirement: string;
+        source_text: string;
+        confidence: "low" | "medium" | "high";
+    }>, "many">;
+    inferred_functional_requirements: z.ZodArray<z.ZodObject<{
+        requirement: z.ZodString;
+        rationale: z.ZodString;
+        domain_pattern: z.ZodString;
+        priority: z.ZodEnum<["critical", "high", "medium", "low"]>;
+    }, "strip", z.ZodTypeAny, {
+        priority: "low" | "medium" | "high" | "critical";
+        requirement: string;
+        rationale: string;
+        domain_pattern: string;
+    }, {
+        priority: "low" | "medium" | "high" | "critical";
+        requirement: string;
+        rationale: string;
+        domain_pattern: string;
+    }>, "many">;
+    suggested_non_functional_requirements: z.ZodArray<z.ZodObject<{
+        category: z.ZodString;
+        requirement: z.ZodString;
+        industry_standard: z.ZodBoolean;
+        customization_needed: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        category: string;
+        requirement: string;
+        industry_standard: boolean;
+        customization_needed: boolean;
+    }, {
+        category: string;
+        requirement: string;
+        industry_standard: boolean;
+        customization_needed: boolean;
+    }>, "many">;
+    requirements_clarification_questions: z.ZodArray<z.ZodObject<{
+        category: z.ZodString;
+        question: z.ZodString;
+        impact_if_unclear: z.ZodString;
+        suggested_default: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        category: string;
+        question: string;
+        impact_if_unclear: string;
+        suggested_default: string;
+    }, {
+        category: string;
+        question: string;
+        impact_if_unclear: string;
+        suggested_default: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    explicit_requirements: {
+        requirement: string;
+        source_text: string;
+        confidence: "low" | "medium" | "high";
+    }[];
+    inferred_functional_requirements: {
+        priority: "low" | "medium" | "high" | "critical";
+        requirement: string;
+        rationale: string;
+        domain_pattern: string;
+    }[];
+    suggested_non_functional_requirements: {
+        category: string;
+        requirement: string;
+        industry_standard: boolean;
+        customization_needed: boolean;
+    }[];
+    requirements_clarification_questions: {
+        category: string;
+        question: string;
+        impact_if_unclear: string;
+        suggested_default: string;
+    }[];
+}, {
+    explicit_requirements: {
+        requirement: string;
+        source_text: string;
+        confidence: "low" | "medium" | "high";
+    }[];
+    inferred_functional_requirements: {
+        priority: "low" | "medium" | "high" | "critical";
+        requirement: string;
+        rationale: string;
+        domain_pattern: string;
+    }[];
+    suggested_non_functional_requirements: {
+        category: string;
+        requirement: string;
+        industry_standard: boolean;
+        customization_needed: boolean;
+    }[];
+    requirements_clarification_questions: {
+        category: string;
+        question: string;
+        impact_if_unclear: string;
+        suggested_default: string;
+    }[];
+}>;
+export declare const FeatureGapSchema: z.ZodObject<{
+    feature: z.ZodString;
+    priority: z.ZodEnum<["critical", "high", "medium", "low"]>;
+    rationale: z.ZodString;
+    suggested_approach: z.ZodString;
+    estimated_effort: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    priority: "low" | "medium" | "high" | "critical";
+    estimated_effort: string;
+    rationale: string;
+    feature: string;
+    suggested_approach: string;
+}, {
+    priority: "low" | "medium" | "high" | "critical";
+    estimated_effort: string;
+    rationale: string;
+    feature: string;
+    suggested_approach: string;
+}>;
+export declare const MissingNonFunctionalRequirementSchema: z.ZodObject<{
+    requirement: z.ZodString;
+    category: z.ZodEnum<["security", "performance", "accessibility", "monitoring", "documentation", "testing", "deployment"]>;
+    impact: z.ZodString;
+    recommendation: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    impact: string;
+    category: "security" | "performance" | "testing" | "accessibility" | "monitoring" | "documentation" | "deployment";
+    requirement: string;
+    recommendation: string;
+}, {
+    impact: string;
+    category: "security" | "performance" | "testing" | "accessibility" | "monitoring" | "documentation" | "deployment";
+    requirement: string;
+    recommendation: string;
+}>;
+export declare const FeatureGapAnalysisSchema: z.ZodObject<{
+    missing_core_features: z.ZodArray<z.ZodObject<{
+        feature: z.ZodString;
+        priority: z.ZodEnum<["critical", "high", "medium", "low"]>;
+        rationale: z.ZodString;
+        suggested_approach: z.ZodString;
+        estimated_effort: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        priority: "low" | "medium" | "high" | "critical";
+        estimated_effort: string;
+        rationale: string;
+        feature: string;
+        suggested_approach: string;
+    }, {
+        priority: "low" | "medium" | "high" | "critical";
+        estimated_effort: string;
+        rationale: string;
+        feature: string;
+        suggested_approach: string;
+    }>, "many">;
+    missing_non_functional_requirements: z.ZodArray<z.ZodObject<{
+        requirement: z.ZodString;
+        category: z.ZodEnum<["security", "performance", "accessibility", "monitoring", "documentation", "testing", "deployment"]>;
+        impact: z.ZodString;
+        recommendation: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        impact: string;
+        category: "security" | "performance" | "testing" | "accessibility" | "monitoring" | "documentation" | "deployment";
+        requirement: string;
+        recommendation: string;
+    }, {
+        impact: string;
+        category: "security" | "performance" | "testing" | "accessibility" | "monitoring" | "documentation" | "deployment";
+        requirement: string;
+        recommendation: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    missing_core_features: {
+        priority: "low" | "medium" | "high" | "critical";
+        estimated_effort: string;
+        rationale: string;
+        feature: string;
+        suggested_approach: string;
+    }[];
+    missing_non_functional_requirements: {
+        impact: string;
+        category: "security" | "performance" | "testing" | "accessibility" | "monitoring" | "documentation" | "deployment";
+        requirement: string;
+        recommendation: string;
+    }[];
+}, {
+    missing_core_features: {
+        priority: "low" | "medium" | "high" | "critical";
+        estimated_effort: string;
+        rationale: string;
+        feature: string;
+        suggested_approach: string;
+    }[];
+    missing_non_functional_requirements: {
+        impact: string;
+        category: "security" | "performance" | "testing" | "accessibility" | "monitoring" | "documentation" | "deployment";
+        requirement: string;
+        recommendation: string;
+    }[];
+}>;
+export declare const TimelinePhaseSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    duration_weeks: z.ZodNumber;
+    start_week: z.ZodNumber;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    deliverables: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    key_milestones: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    resources_required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    risks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    id: string;
+    name: string;
+    duration_weeks: number;
+    start_week: number;
+    dependencies?: string[] | undefined;
+    deliverables?: string[] | undefined;
+    key_milestones?: string[] | undefined;
+    resources_required?: string[] | undefined;
+    risks?: string[] | undefined;
+}, {
+    description: string;
+    id: string;
+    name: string;
+    duration_weeks: number;
+    start_week: number;
+    dependencies?: string[] | undefined;
+    deliverables?: string[] | undefined;
+    key_milestones?: string[] | undefined;
+    resources_required?: string[] | undefined;
+    risks?: string[] | undefined;
+}>;
+export declare const TimelineSchema: z.ZodObject<{
+    total_duration_weeks: z.ZodNumber;
+    phases: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        duration_weeks: z.ZodNumber;
+        start_week: z.ZodNumber;
+        dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        deliverables: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        key_milestones: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        resources_required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        risks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        id: string;
+        name: string;
+        duration_weeks: number;
+        start_week: number;
+        dependencies?: string[] | undefined;
+        deliverables?: string[] | undefined;
+        key_milestones?: string[] | undefined;
+        resources_required?: string[] | undefined;
+        risks?: string[] | undefined;
+    }, {
+        description: string;
+        id: string;
+        name: string;
+        duration_weeks: number;
+        start_week: number;
+        dependencies?: string[] | undefined;
+        deliverables?: string[] | undefined;
+        key_milestones?: string[] | undefined;
+        resources_required?: string[] | undefined;
+        risks?: string[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    total_duration_weeks: number;
+    phases: {
+        description: string;
+        id: string;
+        name: string;
+        duration_weeks: number;
+        start_week: number;
+        dependencies?: string[] | undefined;
+        deliverables?: string[] | undefined;
+        key_milestones?: string[] | undefined;
+        resources_required?: string[] | undefined;
+        risks?: string[] | undefined;
+    }[];
+}, {
+    total_duration_weeks: number;
+    phases: {
+        description: string;
+        id: string;
+        name: string;
+        duration_weeks: number;
+        start_week: number;
+        dependencies?: string[] | undefined;
+        deliverables?: string[] | undefined;
+        key_milestones?: string[] | undefined;
+        resources_required?: string[] | undefined;
+        risks?: string[] | undefined;
+    }[];
+}>;
+export declare const ProjectAnalysisSchema: z.ZodObject<{
+    project_id: z.ZodString;
+    analysis_type: z.ZodEnum<["project_review", "development_plan", "story_implementation"]>;
+    executive_summary: z.ZodString;
+    analysis: z.ZodObject<{
+        strengths: z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            description: z.ZodString;
+            impact: z.ZodEnum<["low", "medium", "high"]>;
+            evidence: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            evidence?: string[] | undefined;
+        }, {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            evidence?: string[] | undefined;
+        }>, "many">;
+        weaknesses: z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            description: z.ZodString;
+            severity: z.ZodEnum<["low", "medium", "high"]>;
+            affected_areas: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            improvement_effort: z.ZodOptional<z.ZodEnum<["minimal", "moderate", "significant"]>>;
+        }, "strip", z.ZodTypeAny, {
+            title: string;
+            description: string;
+            severity: "low" | "medium" | "high";
+            affected_areas?: string[] | undefined;
+            improvement_effort?: "minimal" | "moderate" | "significant" | undefined;
+        }, {
+            title: string;
+            description: string;
+            severity: "low" | "medium" | "high";
+            affected_areas?: string[] | undefined;
+            improvement_effort?: "minimal" | "moderate" | "significant" | undefined;
+        }>, "many">;
+        risks: z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            description: z.ZodString;
+            probability: z.ZodEnum<["low", "medium", "high"]>;
+            impact: z.ZodEnum<["low", "medium", "high"]>;
+            mitigation_strategy: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            probability: "low" | "medium" | "high";
+            mitigation_strategy?: string | undefined;
+        }, {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            probability: "low" | "medium" | "high";
+            mitigation_strategy?: string | undefined;
+        }>, "many">;
+        opportunities: z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            description: z.ZodString;
+            potential_value: z.ZodEnum<["low", "medium", "high"]>;
+            implementation_complexity: z.ZodOptional<z.ZodEnum<["simple", "moderate", "complex"]>>;
+        }, "strip", z.ZodTypeAny, {
+            title: string;
+            description: string;
+            potential_value: "low" | "medium" | "high";
+            implementation_complexity?: "moderate" | "simple" | "complex" | undefined;
+        }, {
+            title: string;
+            description: string;
+            potential_value: "low" | "medium" | "high";
+            implementation_complexity?: "moderate" | "simple" | "complex" | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        risks: {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            probability: "low" | "medium" | "high";
+            mitigation_strategy?: string | undefined;
+        }[];
+        strengths: {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            evidence?: string[] | undefined;
+        }[];
+        weaknesses: {
+            title: string;
+            description: string;
+            severity: "low" | "medium" | "high";
+            affected_areas?: string[] | undefined;
+            improvement_effort?: "minimal" | "moderate" | "significant" | undefined;
+        }[];
+        opportunities: {
+            title: string;
+            description: string;
+            potential_value: "low" | "medium" | "high";
+            implementation_complexity?: "moderate" | "simple" | "complex" | undefined;
+        }[];
+    }, {
+        risks: {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            probability: "low" | "medium" | "high";
+            mitigation_strategy?: string | undefined;
+        }[];
+        strengths: {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            evidence?: string[] | undefined;
+        }[];
+        weaknesses: {
+            title: string;
+            description: string;
+            severity: "low" | "medium" | "high";
+            affected_areas?: string[] | undefined;
+            improvement_effort?: "minimal" | "moderate" | "significant" | undefined;
+        }[];
+        opportunities: {
+            title: string;
+            description: string;
+            potential_value: "low" | "medium" | "high";
+            implementation_complexity?: "moderate" | "simple" | "complex" | undefined;
+        }[];
+    }>;
+    scores: z.ZodObject<{
+        completeness: z.ZodObject<{
+            score: z.ZodNumber;
+            reasoning: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            score: number;
+            reasoning: string;
+        }, {
+            score: number;
+            reasoning: string;
+        }>;
+        clarity: z.ZodObject<{
+            score: z.ZodNumber;
+            reasoning: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            score: number;
+            reasoning: string;
+        }, {
+            score: number;
+            reasoning: string;
+        }>;
+        feasibility: z.ZodObject<{
+            score: z.ZodNumber;
+            reasoning: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            score: number;
+            reasoning: string;
+        }, {
+            score: number;
+            reasoning: string;
+        }>;
+        overall: z.ZodObject<{
+            score: z.ZodNumber;
+            reasoning: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            score: number;
+            reasoning: string;
+        }, {
+            score: number;
+            reasoning: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        completeness: {
+            score: number;
+            reasoning: string;
+        };
+        clarity: {
+            score: number;
+            reasoning: string;
+        };
+        feasibility: {
+            score: number;
+            reasoning: string;
+        };
+        overall: {
+            score: number;
+            reasoning: string;
+        };
+    }, {
+        completeness: {
+            score: number;
+            reasoning: string;
+        };
+        clarity: {
+            score: number;
+            reasoning: string;
+        };
+        feasibility: {
+            score: number;
+            reasoning: string;
+        };
+        overall: {
+            score: number;
+            reasoning: string;
+        };
+    }>;
+    recommendations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        category: z.ZodEnum<["requirements", "architecture", "security", "performance", "maintainability", "testing"]>;
+        title: z.ZodString;
+        description: z.ZodString;
+        implementation_guide: z.ZodOptional<z.ZodString>;
+        priority: z.ZodEnum<["low", "medium", "high", "critical"]>;
+        estimated_effort: z.ZodOptional<z.ZodString>;
+        business_impact: z.ZodOptional<z.ZodString>;
+        technical_complexity: z.ZodOptional<z.ZodEnum<["simple", "moderate", "complex"]>>;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        description: string;
+        id: string;
+        category: "requirements" | "architecture" | "security" | "performance" | "maintainability" | "testing";
+        priority: "low" | "medium" | "high" | "critical";
+        implementation_guide?: string | undefined;
+        estimated_effort?: string | undefined;
+        business_impact?: string | undefined;
+        technical_complexity?: "moderate" | "simple" | "complex" | undefined;
+    }, {
+        title: string;
+        description: string;
+        id: string;
+        category: "requirements" | "architecture" | "security" | "performance" | "maintainability" | "testing";
+        priority: "low" | "medium" | "high" | "critical";
+        implementation_guide?: string | undefined;
+        estimated_effort?: string | undefined;
+        business_impact?: string | undefined;
+        technical_complexity?: "moderate" | "simple" | "complex" | undefined;
+    }>, "many">;
+    suggested_product_requirements: z.ZodObject<{
+        explicit_requirements: z.ZodArray<z.ZodObject<{
+            requirement: z.ZodString;
+            source_text: z.ZodString;
+            confidence: z.ZodEnum<["high", "medium", "low"]>;
+        }, "strip", z.ZodTypeAny, {
+            requirement: string;
+            source_text: string;
+            confidence: "low" | "medium" | "high";
+        }, {
+            requirement: string;
+            source_text: string;
+            confidence: "low" | "medium" | "high";
+        }>, "many">;
+        inferred_functional_requirements: z.ZodArray<z.ZodObject<{
+            requirement: z.ZodString;
+            rationale: z.ZodString;
+            domain_pattern: z.ZodString;
+            priority: z.ZodEnum<["critical", "high", "medium", "low"]>;
+        }, "strip", z.ZodTypeAny, {
+            priority: "low" | "medium" | "high" | "critical";
+            requirement: string;
+            rationale: string;
+            domain_pattern: string;
+        }, {
+            priority: "low" | "medium" | "high" | "critical";
+            requirement: string;
+            rationale: string;
+            domain_pattern: string;
+        }>, "many">;
+        suggested_non_functional_requirements: z.ZodArray<z.ZodObject<{
+            category: z.ZodString;
+            requirement: z.ZodString;
+            industry_standard: z.ZodBoolean;
+            customization_needed: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            category: string;
+            requirement: string;
+            industry_standard: boolean;
+            customization_needed: boolean;
+        }, {
+            category: string;
+            requirement: string;
+            industry_standard: boolean;
+            customization_needed: boolean;
+        }>, "many">;
+        requirements_clarification_questions: z.ZodArray<z.ZodObject<{
+            category: z.ZodString;
+            question: z.ZodString;
+            impact_if_unclear: z.ZodString;
+            suggested_default: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            category: string;
+            question: string;
+            impact_if_unclear: string;
+            suggested_default: string;
+        }, {
+            category: string;
+            question: string;
+            impact_if_unclear: string;
+            suggested_default: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        explicit_requirements: {
+            requirement: string;
+            source_text: string;
+            confidence: "low" | "medium" | "high";
+        }[];
+        inferred_functional_requirements: {
+            priority: "low" | "medium" | "high" | "critical";
+            requirement: string;
+            rationale: string;
+            domain_pattern: string;
+        }[];
+        suggested_non_functional_requirements: {
+            category: string;
+            requirement: string;
+            industry_standard: boolean;
+            customization_needed: boolean;
+        }[];
+        requirements_clarification_questions: {
+            category: string;
+            question: string;
+            impact_if_unclear: string;
+            suggested_default: string;
+        }[];
+    }, {
+        explicit_requirements: {
+            requirement: string;
+            source_text: string;
+            confidence: "low" | "medium" | "high";
+        }[];
+        inferred_functional_requirements: {
+            priority: "low" | "medium" | "high" | "critical";
+            requirement: string;
+            rationale: string;
+            domain_pattern: string;
+        }[];
+        suggested_non_functional_requirements: {
+            category: string;
+            requirement: string;
+            industry_standard: boolean;
+            customization_needed: boolean;
+        }[];
+        requirements_clarification_questions: {
+            category: string;
+            question: string;
+            impact_if_unclear: string;
+            suggested_default: string;
+        }[];
+    }>;
+    feature_gap_analysis: z.ZodOptional<z.ZodObject<{
+        missing_core_features: z.ZodArray<z.ZodObject<{
+            feature: z.ZodString;
+            priority: z.ZodEnum<["critical", "high", "medium", "low"]>;
+            rationale: z.ZodString;
+            suggested_approach: z.ZodString;
+            estimated_effort: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            priority: "low" | "medium" | "high" | "critical";
+            estimated_effort: string;
+            rationale: string;
+            feature: string;
+            suggested_approach: string;
+        }, {
+            priority: "low" | "medium" | "high" | "critical";
+            estimated_effort: string;
+            rationale: string;
+            feature: string;
+            suggested_approach: string;
+        }>, "many">;
+        missing_non_functional_requirements: z.ZodArray<z.ZodObject<{
+            requirement: z.ZodString;
+            category: z.ZodEnum<["security", "performance", "accessibility", "monitoring", "documentation", "testing", "deployment"]>;
+            impact: z.ZodString;
+            recommendation: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            impact: string;
+            category: "security" | "performance" | "testing" | "accessibility" | "monitoring" | "documentation" | "deployment";
+            requirement: string;
+            recommendation: string;
+        }, {
+            impact: string;
+            category: "security" | "performance" | "testing" | "accessibility" | "monitoring" | "documentation" | "deployment";
+            requirement: string;
+            recommendation: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        missing_core_features: {
+            priority: "low" | "medium" | "high" | "critical";
+            estimated_effort: string;
+            rationale: string;
+            feature: string;
+            suggested_approach: string;
+        }[];
+        missing_non_functional_requirements: {
+            impact: string;
+            category: "security" | "performance" | "testing" | "accessibility" | "monitoring" | "documentation" | "deployment";
+            requirement: string;
+            recommendation: string;
+        }[];
+    }, {
+        missing_core_features: {
+            priority: "low" | "medium" | "high" | "critical";
+            estimated_effort: string;
+            rationale: string;
+            feature: string;
+            suggested_approach: string;
+        }[];
+        missing_non_functional_requirements: {
+            impact: string;
+            category: "security" | "performance" | "testing" | "accessibility" | "monitoring" | "documentation" | "deployment";
+            requirement: string;
+            recommendation: string;
+        }[];
+    }>>;
+    metadata: z.ZodObject<{
+        analysis_duration_seconds: z.ZodNumber;
+        claude_model: z.ZodString;
+        confidence_level: z.ZodNumber;
+        analysis_timestamp: z.ZodString;
+        reviewer_notes: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        analysis_duration_seconds: number;
+        claude_model: string;
+        confidence_level: number;
+        analysis_timestamp: string;
+        reviewer_notes?: string | undefined;
+    }, {
+        analysis_duration_seconds: number;
+        claude_model: string;
+        confidence_level: number;
+        analysis_timestamp: string;
+        reviewer_notes?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    project_id: string;
+    analysis_type: "project_review" | "development_plan" | "story_implementation";
+    executive_summary: string;
+    analysis: {
+        risks: {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            probability: "low" | "medium" | "high";
+            mitigation_strategy?: string | undefined;
+        }[];
+        strengths: {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            evidence?: string[] | undefined;
+        }[];
+        weaknesses: {
+            title: string;
+            description: string;
+            severity: "low" | "medium" | "high";
+            affected_areas?: string[] | undefined;
+            improvement_effort?: "minimal" | "moderate" | "significant" | undefined;
+        }[];
+        opportunities: {
+            title: string;
+            description: string;
+            potential_value: "low" | "medium" | "high";
+            implementation_complexity?: "moderate" | "simple" | "complex" | undefined;
+        }[];
+    };
+    scores: {
+        completeness: {
+            score: number;
+            reasoning: string;
+        };
+        clarity: {
+            score: number;
+            reasoning: string;
+        };
+        feasibility: {
+            score: number;
+            reasoning: string;
+        };
+        overall: {
+            score: number;
+            reasoning: string;
+        };
+    };
+    recommendations: {
+        title: string;
+        description: string;
+        id: string;
+        category: "requirements" | "architecture" | "security" | "performance" | "maintainability" | "testing";
+        priority: "low" | "medium" | "high" | "critical";
+        implementation_guide?: string | undefined;
+        estimated_effort?: string | undefined;
+        business_impact?: string | undefined;
+        technical_complexity?: "moderate" | "simple" | "complex" | undefined;
+    }[];
+    suggested_product_requirements: {
+        explicit_requirements: {
+            requirement: string;
+            source_text: string;
+            confidence: "low" | "medium" | "high";
+        }[];
+        inferred_functional_requirements: {
+            priority: "low" | "medium" | "high" | "critical";
+            requirement: string;
+            rationale: string;
+            domain_pattern: string;
+        }[];
+        suggested_non_functional_requirements: {
+            category: string;
+            requirement: string;
+            industry_standard: boolean;
+            customization_needed: boolean;
+        }[];
+        requirements_clarification_questions: {
+            category: string;
+            question: string;
+            impact_if_unclear: string;
+            suggested_default: string;
+        }[];
+    };
+    metadata: {
+        analysis_duration_seconds: number;
+        claude_model: string;
+        confidence_level: number;
+        analysis_timestamp: string;
+        reviewer_notes?: string | undefined;
+    };
+    feature_gap_analysis?: {
+        missing_core_features: {
+            priority: "low" | "medium" | "high" | "critical";
+            estimated_effort: string;
+            rationale: string;
+            feature: string;
+            suggested_approach: string;
+        }[];
+        missing_non_functional_requirements: {
+            impact: string;
+            category: "security" | "performance" | "testing" | "accessibility" | "monitoring" | "documentation" | "deployment";
+            requirement: string;
+            recommendation: string;
+        }[];
+    } | undefined;
+}, {
+    project_id: string;
+    analysis_type: "project_review" | "development_plan" | "story_implementation";
+    executive_summary: string;
+    analysis: {
+        risks: {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            probability: "low" | "medium" | "high";
+            mitigation_strategy?: string | undefined;
+        }[];
+        strengths: {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            evidence?: string[] | undefined;
+        }[];
+        weaknesses: {
+            title: string;
+            description: string;
+            severity: "low" | "medium" | "high";
+            affected_areas?: string[] | undefined;
+            improvement_effort?: "minimal" | "moderate" | "significant" | undefined;
+        }[];
+        opportunities: {
+            title: string;
+            description: string;
+            potential_value: "low" | "medium" | "high";
+            implementation_complexity?: "moderate" | "simple" | "complex" | undefined;
+        }[];
+    };
+    scores: {
+        completeness: {
+            score: number;
+            reasoning: string;
+        };
+        clarity: {
+            score: number;
+            reasoning: string;
+        };
+        feasibility: {
+            score: number;
+            reasoning: string;
+        };
+        overall: {
+            score: number;
+            reasoning: string;
+        };
+    };
+    recommendations: {
+        title: string;
+        description: string;
+        id: string;
+        category: "requirements" | "architecture" | "security" | "performance" | "maintainability" | "testing";
+        priority: "low" | "medium" | "high" | "critical";
+        implementation_guide?: string | undefined;
+        estimated_effort?: string | undefined;
+        business_impact?: string | undefined;
+        technical_complexity?: "moderate" | "simple" | "complex" | undefined;
+    }[];
+    suggested_product_requirements: {
+        explicit_requirements: {
+            requirement: string;
+            source_text: string;
+            confidence: "low" | "medium" | "high";
+        }[];
+        inferred_functional_requirements: {
+            priority: "low" | "medium" | "high" | "critical";
+            requirement: string;
+            rationale: string;
+            domain_pattern: string;
+        }[];
+        suggested_non_functional_requirements: {
+            category: string;
+            requirement: string;
+            industry_standard: boolean;
+            customization_needed: boolean;
+        }[];
+        requirements_clarification_questions: {
+            category: string;
+            question: string;
+            impact_if_unclear: string;
+            suggested_default: string;
+        }[];
+    };
+    metadata: {
+        analysis_duration_seconds: number;
+        claude_model: string;
+        confidence_level: number;
+        analysis_timestamp: string;
+        reviewer_notes?: string | undefined;
+    };
+    feature_gap_analysis?: {
+        missing_core_features: {
+            priority: "low" | "medium" | "high" | "critical";
+            estimated_effort: string;
+            rationale: string;
+            feature: string;
+            suggested_approach: string;
+        }[];
+        missing_non_functional_requirements: {
+            impact: string;
+            category: "security" | "performance" | "testing" | "accessibility" | "monitoring" | "documentation" | "deployment";
+            requirement: string;
+            recommendation: string;
+        }[];
+    } | undefined;
+}>;
+export type AnalysisStrength = z.infer<typeof AnalysisStrengthSchema>;
+export type AnalysisWeakness = z.infer<typeof AnalysisWeaknessSchema>;
+export type AnalysisRisk = z.infer<typeof AnalysisRiskSchema>;
+export type AnalysisOpportunity = z.infer<typeof AnalysisOpportunitySchema>;
+export type ScoreWithReasoning = z.infer<typeof ScoreWithReasoningSchema>;
+export type Recommendation = z.infer<typeof RecommendationSchema>;
+export type ExplicitRequirement = z.infer<typeof ExplicitRequirementSchema>;
+export type InferredRequirement = z.infer<typeof InferredRequirementSchema>;
+export type NonFunctionalRequirement = z.infer<typeof NonFunctionalRequirementSchema>;
+export type ClarificationQuestion = z.infer<typeof ClarificationQuestionSchema>;
+export type SuggestedProductRequirements = z.infer<typeof SuggestedProductRequirementsSchema>;
+export type FeatureGap = z.infer<typeof FeatureGapSchema>;
+export type MissingNonFunctionalRequirement = z.infer<typeof MissingNonFunctionalRequirementSchema>;
+export type FeatureGapAnalysis = z.infer<typeof FeatureGapAnalysisSchema>;
+export type ProjectAnalysis = z.infer<typeof ProjectAnalysisSchema>;
+export declare const ImplementationPlanSchema: z.ZodObject<{
+    project_id: z.ZodString;
+    executive_summary: z.ZodString;
+    analysis: z.ZodObject<{
+        strengths: z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            description: z.ZodString;
+            impact: z.ZodEnum<["low", "medium", "high"]>;
+            evidence: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            evidence?: string[] | undefined;
+        }, {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            evidence?: string[] | undefined;
+        }>, "many">;
+        weaknesses: z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            description: z.ZodString;
+            severity: z.ZodEnum<["low", "medium", "high"]>;
+            affected_areas: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            improvement_effort: z.ZodOptional<z.ZodEnum<["minimal", "moderate", "significant"]>>;
+        }, "strip", z.ZodTypeAny, {
+            title: string;
+            description: string;
+            severity: "low" | "medium" | "high";
+            affected_areas?: string[] | undefined;
+            improvement_effort?: "minimal" | "moderate" | "significant" | undefined;
+        }, {
+            title: string;
+            description: string;
+            severity: "low" | "medium" | "high";
+            affected_areas?: string[] | undefined;
+            improvement_effort?: "minimal" | "moderate" | "significant" | undefined;
+        }>, "many">;
+        risks: z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            description: z.ZodString;
+            probability: z.ZodEnum<["low", "medium", "high"]>;
+            impact: z.ZodEnum<["low", "medium", "high"]>;
+            mitigation_strategy: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            probability: "low" | "medium" | "high";
+            mitigation_strategy?: string | undefined;
+        }, {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            probability: "low" | "medium" | "high";
+            mitigation_strategy?: string | undefined;
+        }>, "many">;
+        opportunities: z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            description: z.ZodString;
+            potential_value: z.ZodEnum<["low", "medium", "high"]>;
+            implementation_complexity: z.ZodOptional<z.ZodEnum<["simple", "moderate", "complex"]>>;
+        }, "strip", z.ZodTypeAny, {
+            title: string;
+            description: string;
+            potential_value: "low" | "medium" | "high";
+            implementation_complexity?: "moderate" | "simple" | "complex" | undefined;
+        }, {
+            title: string;
+            description: string;
+            potential_value: "low" | "medium" | "high";
+            implementation_complexity?: "moderate" | "simple" | "complex" | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        risks: {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            probability: "low" | "medium" | "high";
+            mitigation_strategy?: string | undefined;
+        }[];
+        strengths: {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            evidence?: string[] | undefined;
+        }[];
+        weaknesses: {
+            title: string;
+            description: string;
+            severity: "low" | "medium" | "high";
+            affected_areas?: string[] | undefined;
+            improvement_effort?: "minimal" | "moderate" | "significant" | undefined;
+        }[];
+        opportunities: {
+            title: string;
+            description: string;
+            potential_value: "low" | "medium" | "high";
+            implementation_complexity?: "moderate" | "simple" | "complex" | undefined;
+        }[];
+    }, {
+        risks: {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            probability: "low" | "medium" | "high";
+            mitigation_strategy?: string | undefined;
+        }[];
+        strengths: {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            evidence?: string[] | undefined;
+        }[];
+        weaknesses: {
+            title: string;
+            description: string;
+            severity: "low" | "medium" | "high";
+            affected_areas?: string[] | undefined;
+            improvement_effort?: "minimal" | "moderate" | "significant" | undefined;
+        }[];
+        opportunities: {
+            title: string;
+            description: string;
+            potential_value: "low" | "medium" | "high";
+            implementation_complexity?: "moderate" | "simple" | "complex" | undefined;
+        }[];
+    }>;
+    scores: z.ZodObject<{
+        completeness: z.ZodObject<{
+            score: z.ZodNumber;
+            reasoning: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            score: number;
+            reasoning: string;
+        }, {
+            score: number;
+            reasoning: string;
+        }>;
+        clarity: z.ZodObject<{
+            score: z.ZodNumber;
+            reasoning: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            score: number;
+            reasoning: string;
+        }, {
+            score: number;
+            reasoning: string;
+        }>;
+        feasibility: z.ZodObject<{
+            score: z.ZodNumber;
+            reasoning: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            score: number;
+            reasoning: string;
+        }, {
+            score: number;
+            reasoning: string;
+        }>;
+        overall: z.ZodObject<{
+            score: z.ZodNumber;
+            reasoning: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            score: number;
+            reasoning: string;
+        }, {
+            score: number;
+            reasoning: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        completeness: {
+            score: number;
+            reasoning: string;
+        };
+        clarity: {
+            score: number;
+            reasoning: string;
+        };
+        feasibility: {
+            score: number;
+            reasoning: string;
+        };
+        overall: {
+            score: number;
+            reasoning: string;
+        };
+    }, {
+        completeness: {
+            score: number;
+            reasoning: string;
+        };
+        clarity: {
+            score: number;
+            reasoning: string;
+        };
+        feasibility: {
+            score: number;
+            reasoning: string;
+        };
+        overall: {
+            score: number;
+            reasoning: string;
+        };
+    }>;
+    recommendations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        category: z.ZodEnum<["requirements", "architecture", "security", "performance", "maintainability", "testing"]>;
+        title: z.ZodString;
+        description: z.ZodString;
+        implementation_guide: z.ZodOptional<z.ZodString>;
+        priority: z.ZodEnum<["low", "medium", "high", "critical"]>;
+        estimated_effort: z.ZodOptional<z.ZodString>;
+        business_impact: z.ZodOptional<z.ZodString>;
+        technical_complexity: z.ZodOptional<z.ZodEnum<["simple", "moderate", "complex"]>>;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        description: string;
+        id: string;
+        category: "requirements" | "architecture" | "security" | "performance" | "maintainability" | "testing";
+        priority: "low" | "medium" | "high" | "critical";
+        implementation_guide?: string | undefined;
+        estimated_effort?: string | undefined;
+        business_impact?: string | undefined;
+        technical_complexity?: "moderate" | "simple" | "complex" | undefined;
+    }, {
+        title: string;
+        description: string;
+        id: string;
+        category: "requirements" | "architecture" | "security" | "performance" | "maintainability" | "testing";
+        priority: "low" | "medium" | "high" | "critical";
+        implementation_guide?: string | undefined;
+        estimated_effort?: string | undefined;
+        business_impact?: string | undefined;
+        technical_complexity?: "moderate" | "simple" | "complex" | undefined;
+    }>, "many">;
+    suggested_product_requirements: z.ZodObject<{
+        explicit_requirements: z.ZodArray<z.ZodObject<{
+            requirement: z.ZodString;
+            source_text: z.ZodString;
+            confidence: z.ZodEnum<["high", "medium", "low"]>;
+        }, "strip", z.ZodTypeAny, {
+            requirement: string;
+            source_text: string;
+            confidence: "low" | "medium" | "high";
+        }, {
+            requirement: string;
+            source_text: string;
+            confidence: "low" | "medium" | "high";
+        }>, "many">;
+        inferred_functional_requirements: z.ZodArray<z.ZodObject<{
+            requirement: z.ZodString;
+            rationale: z.ZodString;
+            domain_pattern: z.ZodString;
+            priority: z.ZodEnum<["critical", "high", "medium", "low"]>;
+        }, "strip", z.ZodTypeAny, {
+            priority: "low" | "medium" | "high" | "critical";
+            requirement: string;
+            rationale: string;
+            domain_pattern: string;
+        }, {
+            priority: "low" | "medium" | "high" | "critical";
+            requirement: string;
+            rationale: string;
+            domain_pattern: string;
+        }>, "many">;
+        suggested_non_functional_requirements: z.ZodArray<z.ZodObject<{
+            category: z.ZodString;
+            requirement: z.ZodString;
+            industry_standard: z.ZodBoolean;
+            customization_needed: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            category: string;
+            requirement: string;
+            industry_standard: boolean;
+            customization_needed: boolean;
+        }, {
+            category: string;
+            requirement: string;
+            industry_standard: boolean;
+            customization_needed: boolean;
+        }>, "many">;
+        requirements_clarification_questions: z.ZodArray<z.ZodObject<{
+            category: z.ZodString;
+            question: z.ZodString;
+            impact_if_unclear: z.ZodString;
+            suggested_default: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            category: string;
+            question: string;
+            impact_if_unclear: string;
+            suggested_default: string;
+        }, {
+            category: string;
+            question: string;
+            impact_if_unclear: string;
+            suggested_default: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        explicit_requirements: {
+            requirement: string;
+            source_text: string;
+            confidence: "low" | "medium" | "high";
+        }[];
+        inferred_functional_requirements: {
+            priority: "low" | "medium" | "high" | "critical";
+            requirement: string;
+            rationale: string;
+            domain_pattern: string;
+        }[];
+        suggested_non_functional_requirements: {
+            category: string;
+            requirement: string;
+            industry_standard: boolean;
+            customization_needed: boolean;
+        }[];
+        requirements_clarification_questions: {
+            category: string;
+            question: string;
+            impact_if_unclear: string;
+            suggested_default: string;
+        }[];
+    }, {
+        explicit_requirements: {
+            requirement: string;
+            source_text: string;
+            confidence: "low" | "medium" | "high";
+        }[];
+        inferred_functional_requirements: {
+            priority: "low" | "medium" | "high" | "critical";
+            requirement: string;
+            rationale: string;
+            domain_pattern: string;
+        }[];
+        suggested_non_functional_requirements: {
+            category: string;
+            requirement: string;
+            industry_standard: boolean;
+            customization_needed: boolean;
+        }[];
+        requirements_clarification_questions: {
+            category: string;
+            question: string;
+            impact_if_unclear: string;
+            suggested_default: string;
+        }[];
+    }>;
+    feature_gap_analysis: z.ZodOptional<z.ZodObject<{
+        missing_core_features: z.ZodArray<z.ZodObject<{
+            feature: z.ZodString;
+            priority: z.ZodEnum<["critical", "high", "medium", "low"]>;
+            rationale: z.ZodString;
+            suggested_approach: z.ZodString;
+            estimated_effort: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            priority: "low" | "medium" | "high" | "critical";
+            estimated_effort: string;
+            rationale: string;
+            feature: string;
+            suggested_approach: string;
+        }, {
+            priority: "low" | "medium" | "high" | "critical";
+            estimated_effort: string;
+            rationale: string;
+            feature: string;
+            suggested_approach: string;
+        }>, "many">;
+        missing_non_functional_requirements: z.ZodArray<z.ZodObject<{
+            requirement: z.ZodString;
+            category: z.ZodEnum<["security", "performance", "accessibility", "monitoring", "documentation", "testing", "deployment"]>;
+            impact: z.ZodString;
+            recommendation: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            impact: string;
+            category: "security" | "performance" | "testing" | "accessibility" | "monitoring" | "documentation" | "deployment";
+            requirement: string;
+            recommendation: string;
+        }, {
+            impact: string;
+            category: "security" | "performance" | "testing" | "accessibility" | "monitoring" | "documentation" | "deployment";
+            requirement: string;
+            recommendation: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        missing_core_features: {
+            priority: "low" | "medium" | "high" | "critical";
+            estimated_effort: string;
+            rationale: string;
+            feature: string;
+            suggested_approach: string;
+        }[];
+        missing_non_functional_requirements: {
+            impact: string;
+            category: "security" | "performance" | "testing" | "accessibility" | "monitoring" | "documentation" | "deployment";
+            requirement: string;
+            recommendation: string;
+        }[];
+    }, {
+        missing_core_features: {
+            priority: "low" | "medium" | "high" | "critical";
+            estimated_effort: string;
+            rationale: string;
+            feature: string;
+            suggested_approach: string;
+        }[];
+        missing_non_functional_requirements: {
+            impact: string;
+            category: "security" | "performance" | "testing" | "accessibility" | "monitoring" | "documentation" | "deployment";
+            requirement: string;
+            recommendation: string;
+        }[];
+    }>>;
+    metadata: z.ZodObject<{
+        analysis_duration_seconds: z.ZodNumber;
+        claude_model: z.ZodString;
+        confidence_level: z.ZodNumber;
+        analysis_timestamp: z.ZodString;
+        reviewer_notes: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        analysis_duration_seconds: number;
+        claude_model: string;
+        confidence_level: number;
+        analysis_timestamp: string;
+        reviewer_notes?: string | undefined;
+    }, {
+        analysis_duration_seconds: number;
+        claude_model: string;
+        confidence_level: number;
+        analysis_timestamp: string;
+        reviewer_notes?: string | undefined;
+    }>;
+} & {
+    analysis_type: z.ZodLiteral<"implementation_plan">;
+    timeline: z.ZodObject<{
+        total_duration_weeks: z.ZodNumber;
+        phases: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodString;
+            duration_weeks: z.ZodNumber;
+            start_week: z.ZodNumber;
+            dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            deliverables: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            key_milestones: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            resources_required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            risks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            description: string;
+            id: string;
+            name: string;
+            duration_weeks: number;
+            start_week: number;
+            dependencies?: string[] | undefined;
+            deliverables?: string[] | undefined;
+            key_milestones?: string[] | undefined;
+            resources_required?: string[] | undefined;
+            risks?: string[] | undefined;
+        }, {
+            description: string;
+            id: string;
+            name: string;
+            duration_weeks: number;
+            start_week: number;
+            dependencies?: string[] | undefined;
+            deliverables?: string[] | undefined;
+            key_milestones?: string[] | undefined;
+            resources_required?: string[] | undefined;
+            risks?: string[] | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        total_duration_weeks: number;
+        phases: {
+            description: string;
+            id: string;
+            name: string;
+            duration_weeks: number;
+            start_week: number;
+            dependencies?: string[] | undefined;
+            deliverables?: string[] | undefined;
+            key_milestones?: string[] | undefined;
+            resources_required?: string[] | undefined;
+            risks?: string[] | undefined;
+        }[];
+    }, {
+        total_duration_weeks: number;
+        phases: {
+            description: string;
+            id: string;
+            name: string;
+            duration_weeks: number;
+            start_week: number;
+            dependencies?: string[] | undefined;
+            deliverables?: string[] | undefined;
+            key_milestones?: string[] | undefined;
+            resources_required?: string[] | undefined;
+            risks?: string[] | undefined;
+        }[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    project_id: string;
+    analysis_type: "implementation_plan";
+    executive_summary: string;
+    analysis: {
+        risks: {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            probability: "low" | "medium" | "high";
+            mitigation_strategy?: string | undefined;
+        }[];
+        strengths: {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            evidence?: string[] | undefined;
+        }[];
+        weaknesses: {
+            title: string;
+            description: string;
+            severity: "low" | "medium" | "high";
+            affected_areas?: string[] | undefined;
+            improvement_effort?: "minimal" | "moderate" | "significant" | undefined;
+        }[];
+        opportunities: {
+            title: string;
+            description: string;
+            potential_value: "low" | "medium" | "high";
+            implementation_complexity?: "moderate" | "simple" | "complex" | undefined;
+        }[];
+    };
+    scores: {
+        completeness: {
+            score: number;
+            reasoning: string;
+        };
+        clarity: {
+            score: number;
+            reasoning: string;
+        };
+        feasibility: {
+            score: number;
+            reasoning: string;
+        };
+        overall: {
+            score: number;
+            reasoning: string;
+        };
+    };
+    recommendations: {
+        title: string;
+        description: string;
+        id: string;
+        category: "requirements" | "architecture" | "security" | "performance" | "maintainability" | "testing";
+        priority: "low" | "medium" | "high" | "critical";
+        implementation_guide?: string | undefined;
+        estimated_effort?: string | undefined;
+        business_impact?: string | undefined;
+        technical_complexity?: "moderate" | "simple" | "complex" | undefined;
+    }[];
+    suggested_product_requirements: {
+        explicit_requirements: {
+            requirement: string;
+            source_text: string;
+            confidence: "low" | "medium" | "high";
+        }[];
+        inferred_functional_requirements: {
+            priority: "low" | "medium" | "high" | "critical";
+            requirement: string;
+            rationale: string;
+            domain_pattern: string;
+        }[];
+        suggested_non_functional_requirements: {
+            category: string;
+            requirement: string;
+            industry_standard: boolean;
+            customization_needed: boolean;
+        }[];
+        requirements_clarification_questions: {
+            category: string;
+            question: string;
+            impact_if_unclear: string;
+            suggested_default: string;
+        }[];
+    };
+    metadata: {
+        analysis_duration_seconds: number;
+        claude_model: string;
+        confidence_level: number;
+        analysis_timestamp: string;
+        reviewer_notes?: string | undefined;
+    };
+    timeline: {
+        total_duration_weeks: number;
+        phases: {
+            description: string;
+            id: string;
+            name: string;
+            duration_weeks: number;
+            start_week: number;
+            dependencies?: string[] | undefined;
+            deliverables?: string[] | undefined;
+            key_milestones?: string[] | undefined;
+            resources_required?: string[] | undefined;
+            risks?: string[] | undefined;
+        }[];
+    };
+    feature_gap_analysis?: {
+        missing_core_features: {
+            priority: "low" | "medium" | "high" | "critical";
+            estimated_effort: string;
+            rationale: string;
+            feature: string;
+            suggested_approach: string;
+        }[];
+        missing_non_functional_requirements: {
+            impact: string;
+            category: "security" | "performance" | "testing" | "accessibility" | "monitoring" | "documentation" | "deployment";
+            requirement: string;
+            recommendation: string;
+        }[];
+    } | undefined;
+}, {
+    project_id: string;
+    analysis_type: "implementation_plan";
+    executive_summary: string;
+    analysis: {
+        risks: {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            probability: "low" | "medium" | "high";
+            mitigation_strategy?: string | undefined;
+        }[];
+        strengths: {
+            title: string;
+            description: string;
+            impact: "low" | "medium" | "high";
+            evidence?: string[] | undefined;
+        }[];
+        weaknesses: {
+            title: string;
+            description: string;
+            severity: "low" | "medium" | "high";
+            affected_areas?: string[] | undefined;
+            improvement_effort?: "minimal" | "moderate" | "significant" | undefined;
+        }[];
+        opportunities: {
+            title: string;
+            description: string;
+            potential_value: "low" | "medium" | "high";
+            implementation_complexity?: "moderate" | "simple" | "complex" | undefined;
+        }[];
+    };
+    scores: {
+        completeness: {
+            score: number;
+            reasoning: string;
+        };
+        clarity: {
+            score: number;
+            reasoning: string;
+        };
+        feasibility: {
+            score: number;
+            reasoning: string;
+        };
+        overall: {
+            score: number;
+            reasoning: string;
+        };
+    };
+    recommendations: {
+        title: string;
+        description: string;
+        id: string;
+        category: "requirements" | "architecture" | "security" | "performance" | "maintainability" | "testing";
+        priority: "low" | "medium" | "high" | "critical";
+        implementation_guide?: string | undefined;
+        estimated_effort?: string | undefined;
+        business_impact?: string | undefined;
+        technical_complexity?: "moderate" | "simple" | "complex" | undefined;
+    }[];
+    suggested_product_requirements: {
+        explicit_requirements: {
+            requirement: string;
+            source_text: string;
+            confidence: "low" | "medium" | "high";
+        }[];
+        inferred_functional_requirements: {
+            priority: "low" | "medium" | "high" | "critical";
+            requirement: string;
+            rationale: string;
+            domain_pattern: string;
+        }[];
+        suggested_non_functional_requirements: {
+            category: string;
+            requirement: string;
+            industry_standard: boolean;
+            customization_needed: boolean;
+        }[];
+        requirements_clarification_questions: {
+            category: string;
+            question: string;
+            impact_if_unclear: string;
+            suggested_default: string;
+        }[];
+    };
+    metadata: {
+        analysis_duration_seconds: number;
+        claude_model: string;
+        confidence_level: number;
+        analysis_timestamp: string;
+        reviewer_notes?: string | undefined;
+    };
+    timeline: {
+        total_duration_weeks: number;
+        phases: {
+            description: string;
+            id: string;
+            name: string;
+            duration_weeks: number;
+            start_week: number;
+            dependencies?: string[] | undefined;
+            deliverables?: string[] | undefined;
+            key_milestones?: string[] | undefined;
+            resources_required?: string[] | undefined;
+            risks?: string[] | undefined;
+        }[];
+    };
+    feature_gap_analysis?: {
+        missing_core_features: {
+            priority: "low" | "medium" | "high" | "critical";
+            estimated_effort: string;
+            rationale: string;
+            feature: string;
+            suggested_approach: string;
+        }[];
+        missing_non_functional_requirements: {
+            impact: string;
+            category: "security" | "performance" | "testing" | "accessibility" | "monitoring" | "documentation" | "deployment";
+            requirement: string;
+            recommendation: string;
+        }[];
+    } | undefined;
+}>;
+export type ImplementationPlan = z.infer<typeof ImplementationPlanSchema>;