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>;
