recoder-shared
Version:
Shared types, utilities, and configurations for Recoder
1,244 lines (1,092 loc) • 28.6 kB
text/typescript
/**
* Planning types and interfaces for project requirements, architecture, and validation
*/
import { ProjectType, Environment, ValidationLevel, RealityCheckConfig } from './common';
export enum PlanningPhase {
DISCOVERY = 'discovery',
REQUIREMENTS = 'requirements',
ARCHITECTURE = 'architecture',
DESIGN = 'design',
VALIDATION = 'validation',
APPROVAL = 'approval',
IMPLEMENTATION = 'implementation'
}
export enum RequirementType {
FUNCTIONAL = 'functional',
NON_FUNCTIONAL = 'non_functional',
BUSINESS = 'business',
TECHNICAL = 'technical',
SECURITY = 'security',
COMPLIANCE = 'compliance',
INTEGRATION = 'integration',
DATA = 'data'
}
export enum ArchitecturePattern {
MONOLITHIC = 'monolithic',
MICROSERVICES = 'microservices',
SERVERLESS = 'serverless',
EVENT_DRIVEN = 'event_driven',
LAYERED = 'layered',
HEXAGONAL = 'hexagonal',
CQRS = 'cqrs',
EVENT_SOURCING = 'event_sourcing',
JAMSTACK = 'jamstack',
SPA = 'spa',
SSR = 'ssr',
HYBRID = 'hybrid'
}
export interface PlanningRequest {
projectId?: string;
description: string;
type: ProjectType;
scope: ProjectScope;
constraints: PlanningConstraints;
preferences: PlanningPreferences;
context: PlanningContext;
stakeholders: Stakeholder[];
timeline: TimelineRequirement;
budget: BudgetConstraint;
quality: QualityRequirement;
realityCheck: RealityCheckConfig;
}
export interface ProjectScope {
overview: string;
goals: string[];
objectives: string[];
deliverables: string[];
exclusions: string[];
assumptions: string[];
dependencies: string[];
risks: string[];
successCriteria: string[];
}
export interface PlanningConstraints {
technical: TechnicalConstraint[];
business: BusinessConstraint[];
regulatory: RegulatoryConstraint[];
resource: ResourceConstraint[];
integration: IntegrationConstraint[];
}
export interface TechnicalConstraint {
type: 'language' | 'framework' | 'platform' | 'database' | 'cloud' | 'security' | 'performance';
requirement: string;
reason: string;
flexibility: 'mandatory' | 'preferred' | 'flexible';
alternatives: string[];
}
export interface BusinessConstraint {
type: 'budget' | 'timeline' | 'resources' | 'compliance' | 'market' | 'competitive';
description: string;
impact: 'low' | 'medium' | 'high' | 'critical';
mitigation: string[];
}
export interface RegulatoryConstraint {
regulation: string;
jurisdiction: string;
requirements: string[];
compliance_level: 'partial' | 'full' | 'certified';
audit_required: boolean;
documentation: string[];
}
export interface ResourceConstraint {
type: 'team' | 'skill' | 'tool' | 'infrastructure' | 'time' | 'budget';
limitation: string;
availability: string;
workaround: string[];
}
export interface IntegrationConstraint {
system: string;
type: 'mandatory' | 'optional' | 'future';
protocol: string;
dataFormat: string;
securityRequirements: string[];
performance: PerformanceRequirement;
}
export interface PerformanceRequirement {
responseTime: number; // milliseconds
throughput: number; // requests per second
availability: number; // percentage
scalability: 'fixed' | 'auto' | 'elastic';
concurrency: number;
}
export interface PlanningPreferences {
architectureStyle: ArchitecturePattern[];
technologyStack: TechnologyPreference[];
deploymentModel: DeploymentPreference;
developmentMethodology: 'agile' | 'waterfall' | 'hybrid' | 'devops';
qualityApproach: QualityApproach;
securityApproach: SecurityApproach;
scalingStrategy: ScalingStrategy;
}
export interface TechnologyPreference {
category: 'frontend' | 'backend' | 'database' | 'cache' | 'queue' | 'monitoring' | 'ci_cd';
preferred: string[];
avoided: string[];
experience: 'novice' | 'intermediate' | 'advanced' | 'expert';
rationale: string;
}
export interface DeploymentPreference {
environment: 'cloud' | 'on_premise' | 'hybrid' | 'edge';
provider: string[];
containerization: boolean;
orchestration: 'kubernetes' | 'docker_swarm' | 'nomad' | 'none';
automation: 'full' | 'partial' | 'manual';
}
export interface QualityApproach {
testingStrategy: TestingStrategy;
codeQualityStandards: CodeQualityStandard[];
reviewProcess: ReviewProcess;
documentation: DocumentationStandard;
monitoring: MonitoringStrategy;
}
export interface TestingStrategy {
levels: TestingLevel[];
coverage: CoverageRequirement;
automation: AutomationStrategy;
tools: string[];
environments: Environment[];
}
export interface TestingLevel {
type: 'unit' | 'integration' | 'e2e' | 'performance' | 'security' | 'accessibility';
coverage: number; // percentage
automation: boolean;
frequency: 'commit' | 'daily' | 'release' | 'manual';
}
export interface CoverageRequirement {
minimum: number;
target: number;
critical_paths: number;
branch_coverage: boolean;
mutation_testing: boolean;
}
export interface AutomationStrategy {
level: 'minimal' | 'moderate' | 'comprehensive' | 'full';
triggers: string[];
pipeline_integration: boolean;
reporting: boolean;
}
export interface CodeQualityStandard {
metric: 'complexity' | 'maintainability' | 'reliability' | 'security' | 'duplication';
threshold: number;
enforcement: 'warning' | 'error' | 'blocking';
tools: string[];
}
export interface ReviewProcess {
required: boolean;
reviewers: number;
automated_checks: string[];
approval_criteria: string[];
documentation_required: boolean;
}
export interface DocumentationStandard {
level: 'minimal' | 'standard' | 'comprehensive' | 'enterprise';
formats: string[];
automation: boolean;
maintenance: string;
}
export interface MonitoringStrategy {
level: 'basic' | 'standard' | 'advanced' | 'enterprise';
metrics: string[];
alerting: AlertingStrategy;
logging: LoggingStrategy;
tracing: TracingStrategy;
}
export interface AlertingStrategy {
channels: string[];
severities: string[];
escalation: boolean;
suppression: boolean;
}
export interface LoggingStrategy {
level: 'error' | 'warn' | 'info' | 'debug' | 'trace';
structured: boolean;
centralized: boolean;
retention: string;
}
export interface TracingStrategy {
enabled: boolean;
distributed: boolean;
sampling: number; // percentage
correlation: boolean;
}
export interface SecurityApproach {
model: SecurityModel;
compliance: ComplianceRequirement[];
practices: SecurityPractice[];
tools: SecurityTool[];
training: SecurityTraining;
}
export interface SecurityModel {
paradigm: 'perimeter' | 'zero_trust' | 'defense_in_depth' | 'risk_based';
authentication: AuthenticationStrategy;
authorization: AuthorizationStrategy;
encryption: EncryptionStrategy;
monitoring: SecurityMonitoring;
}
export interface AuthenticationStrategy {
methods: string[];
multi_factor: boolean;
sso: boolean;
session_management: string;
password_policy: PasswordPolicy;
}
export interface PasswordPolicy {
min_length: number;
complexity: string[];
rotation: number; // days
history: number;
lockout: LockoutPolicy;
}
export interface LockoutPolicy {
attempts: number;
duration: number; // minutes
progressive: boolean;
}
export interface AuthorizationStrategy {
model: 'rbac' | 'abac' | 'pbac' | 'custom';
granularity: 'coarse' | 'fine' | 'attribute_based';
centralized: boolean;
delegation: boolean;
}
export interface EncryptionStrategy {
at_rest: EncryptionConfig;
in_transit: EncryptionConfig;
key_management: KeyManagementStrategy;
}
export interface EncryptionConfig {
algorithm: string;
key_size: number;
mode: string;
padding: string;
}
export interface KeyManagementStrategy {
storage: 'hsm' | 'kms' | 'vault' | 'local';
rotation: number; // days
escrow: boolean;
separation: boolean;
}
export interface SecurityMonitoring {
real_time: boolean;
behavioral: boolean;
threat_intelligence: boolean;
incident_response: IncidentResponsePlan;
}
export interface IncidentResponsePlan {
procedures: string[];
escalation: string[];
communication: string[];
recovery: string[];
lessons_learned: boolean;
}
export interface ComplianceRequirement {
standard: string;
scope: string[];
evidence: string[];
audit: AuditRequirement;
certification: boolean;
}
export interface AuditRequirement {
frequency: string;
scope: string[];
documentation: string[];
retention: number; // years
}
export interface SecurityPractice {
practice: string;
implementation: string;
validation: string[];
automation: boolean;
}
export interface SecurityTool {
category: 'sast' | 'dast' | 'iast' | 'sca' | 'secrets' | 'compliance';
tool: string;
integration: string[];
automation: boolean;
}
export interface SecurityTraining {
required: boolean;
frequency: string;
topics: string[];
certification: boolean;
}
export interface ScalingStrategy {
approach: 'horizontal' | 'vertical' | 'both';
triggers: ScalingTrigger[];
limits: ScalingLimit[];
automation: boolean;
cost_optimization: boolean;
}
export interface ScalingTrigger {
metric: string;
threshold: number;
operator: 'gt' | 'lt' | 'eq' | 'gte' | 'lte';
duration: number; // seconds
}
export interface ScalingLimit {
resource: string;
minimum: number;
maximum: number;
step_size: number;
}
export interface PlanningContext {
existing_systems: ExistingSystem[];
team_profile: TeamProfile;
organizational_context: OrganizationalContext;
market_context: MarketContext;
technical_context: TechnicalContext;
}
export interface ExistingSystem {
name: string;
type: string;
technology: string[];
integration_points: string[];
dependencies: string[];
constraints: string[];
migration_strategy: 'replace' | 'integrate' | 'coexist' | 'retire';
}
export interface TeamProfile {
size: number;
experience: ExperienceProfile;
skills: SkillProfile[];
availability: AvailabilityProfile;
location: LocationProfile;
methodology_experience: string[];
}
export interface ExperienceProfile {
average_years: number;
domain_experience: string[];
technology_experience: string[];
methodology_experience: string[];
project_complexity: 'simple' | 'moderate' | 'complex' | 'very_complex';
}
export interface SkillProfile {
skill: string;
level: 'novice' | 'intermediate' | 'advanced' | 'expert';
team_members: number;
critical: boolean;
training_available: boolean;
}
export interface AvailabilityProfile {
full_time: number;
part_time: number;
contractor: number;
timeline_flexibility: 'rigid' | 'moderate' | 'flexible';
}
export interface LocationProfile {
co_located: boolean;
time_zones: string[];
languages: string[];
cultural_considerations: string[];
}
export interface OrganizationalContext {
industry: string;
size: 'startup' | 'small' | 'medium' | 'large' | 'enterprise';
culture: 'conservative' | 'moderate' | 'innovative' | 'disruptive';
risk_tolerance: 'low' | 'medium' | 'high';
change_readiness: 'low' | 'medium' | 'high';
governance: GovernanceProfile;
}
export interface GovernanceProfile {
approval_process: 'simple' | 'moderate' | 'complex';
compliance_requirements: string[];
audit_requirements: string[];
documentation_standards: string[];
security_policies: string[];
}
export interface MarketContext {
competition: 'low' | 'medium' | 'high' | 'intense';
time_to_market: 'flexible' | 'moderate' | 'aggressive';
innovation_pressure: 'low' | 'medium' | 'high';
cost_pressure: 'low' | 'medium' | 'high';
quality_expectations: 'basic' | 'standard' | 'high' | 'premium';
}
export interface TechnicalContext {
current_architecture: string[];
legacy_systems: string[];
infrastructure: InfrastructureContext;
data_landscape: DataLandscape;
integration_landscape: IntegrationLandscape;
}
export interface InfrastructureContext {
current_platforms: string[];
cloud_adoption: 'none' | 'hybrid' | 'cloud_first' | 'cloud_native';
containerization: 'none' | 'basic' | 'intermediate' | 'advanced';
automation: 'manual' | 'basic' | 'intermediate' | 'advanced';
monitoring: 'basic' | 'intermediate' | 'advanced' | 'enterprise';
}
export interface DataLandscape {
sources: DataSource[];
volumes: VolumeProfile;
quality: DataQualityProfile;
governance: DataGovernanceProfile;
privacy: DataPrivacyProfile;
}
export interface DataSource {
name: string;
type: 'database' | 'file' | 'api' | 'stream' | 'external';
technology: string;
volume: 'small' | 'medium' | 'large' | 'very_large';
quality: 'poor' | 'fair' | 'good' | 'excellent';
availability: number; // percentage
}
export interface VolumeProfile {
current: string;
growth_rate: number; // percentage per year
peak_patterns: string[];
storage_requirements: string;
}
export interface DataQualityProfile {
accuracy: number; // percentage
completeness: number; // percentage
consistency: number; // percentage
timeliness: 'real_time' | 'near_real_time' | 'batch' | 'delayed';
}
export interface DataGovernanceProfile {
policies: string[];
ownership: 'centralized' | 'federated' | 'distributed';
lineage: boolean;
catalog: boolean;
quality_monitoring: boolean;
}
export interface DataPrivacyProfile {
regulations: string[];
classification: DataClassification[];
retention: RetentionPolicy[];
access_controls: AccessControlPolicy[];
}
export interface DataClassification {
level: 'public' | 'internal' | 'confidential' | 'restricted';
criteria: string[];
handling: string[];
}
export interface RetentionPolicy {
data_type: string;
retention_period: string;
archival_strategy: string;
disposal_method: string;
}
export interface AccessControlPolicy {
data_type: string;
access_level: string[];
approval_required: boolean;
logging_required: boolean;
}
export interface IntegrationLandscape {
current_integrations: Integration[];
patterns: string[];
tools: string[];
governance: IntegrationGovernance;
}
export interface Integration {
name: string;
type: 'sync' | 'async' | 'batch' | 'real_time';
protocol: string;
data_format: string;
frequency: string;
reliability: number; // percentage
}
export interface IntegrationGovernance {
standards: string[];
approval_process: string[];
monitoring: boolean;
documentation: boolean;
}
export interface Stakeholder {
id: string;
name: string;
role: string;
department: string;
influence: 'low' | 'medium' | 'high' | 'very_high';
interest: 'low' | 'medium' | 'high' | 'very_high';
availability: 'limited' | 'moderate' | 'high';
communication_preference: string[];
decision_authority: string[];
concerns: string[];
expectations: string[];
}
export interface TimelineRequirement {
deadline: string;
flexibility: 'fixed' | 'some' | 'flexible';
milestones: TimelineMilestone[];
dependencies: TimelineDependency[];
constraints: string[];
buffer_time: number; // percentage
}
export interface TimelineMilestone {
name: string;
description: string;
date: string;
type: 'hard' | 'soft' | 'target';
deliverables: string[];
dependencies: string[];
}
export interface TimelineDependency {
name: string;
type: 'internal' | 'external' | 'resource' | 'approval';
impact: 'low' | 'medium' | 'high' | 'critical';
mitigation: string[];
}
export interface BudgetConstraint {
total: number;
currency: string;
breakdown: BudgetBreakdown;
flexibility: 'fixed' | 'some' | 'flexible';
approval_thresholds: ApprovalThreshold[];
contingency: number; // percentage
}
export interface BudgetBreakdown {
development: number;
infrastructure: number;
licenses: number;
training: number;
external_services: number;
contingency: number;
}
export interface ApprovalThreshold {
amount: number;
approver: string;
process: string[];
}
export interface QualityRequirement {
standards: QualityStandard[];
metrics: QualityMetric[];
processes: QualityProcess[];
gates: QualityGate[];
assurance: QualityAssurance;
}
export interface QualityStandard {
name: string;
description: string;
mandatory: boolean;
measurement: string[];
validation: string[];
}
export interface QualityMetric {
name: string;
target: number;
threshold: number;
measurement: string;
frequency: string;
}
export interface QualityProcess {
name: string;
description: string;
participants: string[];
artifacts: string[];
criteria: string[];
}
export interface QualityGate {
name: string;
phase: string;
criteria: string[];
automation: boolean;
bypass_conditions: string[];
}
export interface QualityAssurance {
independent_review: boolean;
external_audit: boolean;
certification: string[];
continuous_monitoring: boolean;
}
export interface PlanningResponse {
planId: string;
status: 'draft' | 'review' | 'approved' | 'rejected' | 'revision_required';
confidence: number; // 0-1 score
plan: DetailedPlan;
alternatives: AlternativePlan[];
risks: IdentifiedRisk[];
recommendations: PlanningRecommendation[];
validation: PlanValidation;
estimations: ProjectEstimation;
nextSteps: NextStep[];
approvals: ApprovalRequirement[];
}
export interface DetailedPlan {
overview: PlanOverview;
architecture: ArchitecturalPlan;
implementation: ImplementationPlan;
testing: TestingPlan;
deployment: DeploymentPlan;
operations: OperationalPlan;
governance: GovernancePlan;
}
export interface PlanOverview {
summary: string;
approach: string;
key_decisions: KeyDecision[];
assumptions: string[];
constraints: string[];
success_factors: string[];
}
export interface KeyDecision {
decision: string;
rationale: string;
alternatives: string[];
trade_offs: string[];
reversibility: 'reversible' | 'difficult' | 'irreversible';
}
export interface ArchitecturalPlan {
pattern: ArchitecturePattern;
components: PlannedComponent[];
data_architecture: DataArchitecture;
integration_architecture: IntegrationArchitecture;
security_architecture: SecurityArchitecture;
deployment_architecture: DeploymentArchitecture;
}
export interface PlannedComponent {
name: string;
type: string;
technology: string;
responsibilities: string[];
interfaces: string[];
dependencies: string[];
non_functional_requirements: string[];
implementation_notes: string[];
}
export interface DataArchitecture {
model: string;
storage: StorageStrategy[];
processing: ProcessingStrategy[];
governance: string[];
security: string[];
}
export interface StorageStrategy {
type: string;
technology: string;
use_cases: string[];
capacity: string;
performance: string;
backup: string;
}
export interface ProcessingStrategy {
type: string;
technology: string;
patterns: string[];
performance: string;
scalability: string;
}
export interface IntegrationArchitecture {
patterns: string[];
protocols: string[];
security: string[];
governance: string[];
monitoring: string[];
}
export interface SecurityArchitecture {
model: string;
layers: SecurityLayer[];
controls: SecurityControl[];
monitoring: string[];
incident_response: string[];
}
export interface SecurityLayer {
name: string;
purpose: string;
technologies: string[];
controls: string[];
}
export interface SecurityControl {
name: string;
type: string;
implementation: string;
validation: string[];
}
export interface DeploymentArchitecture {
strategy: string;
environments: PlannedEnvironment[];
pipeline: string[];
automation: string[];
monitoring: string[];
}
export interface PlannedEnvironment {
name: Environment;
purpose: string;
infrastructure: string[];
configuration: string[];
data: string[];
}
export interface ImplementationPlan {
phases: ImplementationPhase[];
work_packages: WorkPackage[];
dependencies: Dependency[];
resources: ResourcePlan[];
timeline: ImplementationTimeline;
}
export interface ImplementationPhase {
name: string;
objective: string;
deliverables: string[];
duration: string;
resources: string[];
risks: string[];
success_criteria: string[];
}
export interface WorkPackage {
id: string;
name: string;
description: string;
effort: number; // hours
skills: string[];
dependencies: string[];
deliverables: string[];
acceptance_criteria: string[];
}
export interface Dependency {
id: string;
name: string;
type: 'technical' | 'resource' | 'external' | 'approval';
description: string;
impact: 'low' | 'medium' | 'high' | 'critical';
mitigation: string[];
}
export interface ResourcePlan {
role: string;
skills: string[];
effort: number; // hours
duration: string;
availability: string;
alternatives: string[];
}
export interface ImplementationTimeline {
start_date: string;
end_date: string;
milestones: PlannedMilestone[];
critical_path: string[];
buffer_time: number; // percentage
}
export interface PlannedMilestone {
name: string;
date: string;
deliverables: string[];
criteria: string[];
dependencies: string[];
}
export interface TestingPlan {
strategy: TestStrategy;
levels: TestLevel[];
automation: TestAutomation;
data: TestData;
environments: TestEnvironment[];
}
export interface TestStrategy {
approach: string;
scope: string[];
priorities: string[];
criteria: string[];
tools: string[];
}
export interface TestLevel {
type: string;
scope: string[];
automation: boolean;
tools: string[];
coverage: number; // percentage
}
export interface TestAutomation {
framework: string;
tools: string[];
pipeline_integration: boolean;
reporting: string[];
maintenance: string[];
}
export interface TestData {
strategy: string;
sources: string[];
management: string[];
privacy: string[];
refresh: string[];
}
export interface TestEnvironment {
name: string;
purpose: string[];
configuration: string[];
data: string[];
availability: string;
}
export interface DeploymentPlan {
strategy: string;
environments: string[];
pipeline: DeploymentPipeline;
rollback: RollbackStrategy;
monitoring: string[];
}
export interface DeploymentPipeline {
stages: PipelineStage[];
triggers: string[];
approvals: string[];
notifications: string[];
security: string[];
}
export interface PipelineStage {
name: string;
type: string;
actions: string[];
conditions: string[];
rollback: string[];
}
export interface RollbackStrategy {
triggers: string[];
procedures: string[];
data_handling: string[];
communication: string[];
}
export interface OperationalPlan {
monitoring: OperationalMonitoring;
maintenance: MaintenancePlan;
support: SupportPlan;
capacity: CapacityPlan;
disaster_recovery: DisasterRecoveryPlan;
}
export interface OperationalMonitoring {
metrics: string[];
alerting: string[];
dashboards: string[];
reporting: string[];
tools: string[];
}
export interface MaintenancePlan {
schedule: string[];
procedures: string[];
windows: string[];
communication: string[];
rollback: string[];
}
export interface SupportPlan {
model: string;
levels: SupportLevel[];
escalation: string[];
knowledge_base: string[];
training: string[];
}
export interface SupportLevel {
level: string;
scope: string[];
response_time: string;
availability: string;
skills: string[];
}
export interface CapacityPlan {
current: string[];
projections: string[];
scaling: string[];
monitoring: string[];
thresholds: string[];
}
export interface DisasterRecoveryPlan {
scenarios: string[];
procedures: string[];
rto: string; // Recovery Time Objective
rpo: string; // Recovery Point Objective
testing: string[];
}
export interface GovernancePlan {
framework: string;
processes: GovernanceProcess[];
roles: GovernanceRole[];
decisions: DecisionFramework;
compliance: CompliancePlan;
}
export interface GovernanceProcess {
name: string;
purpose: string;
participants: string[];
frequency: string;
deliverables: string[];
}
export interface GovernanceRole {
role: string;
responsibilities: string[];
authority: string[];
accountability: string[];
}
export interface DecisionFramework {
levels: DecisionLevel[];
escalation: string[];
documentation: string[];
review: string[];
}
export interface DecisionLevel {
level: string;
scope: string[];
authority: string[];
process: string[];
}
export interface CompliancePlan {
requirements: string[];
controls: string[];
monitoring: string[];
reporting: string[];
audit: string[];
}
export interface AlternativePlan {
id: string;
name: string;
description: string;
approach: string;
trade_offs: TradeOff[];
effort: number;
timeline: string;
risk: number;
confidence: number;
}
export interface TradeOff {
aspect: string;
benefit: string;
cost: string;
impact: 'low' | 'medium' | 'high';
}
export interface IdentifiedRisk {
id: string;
category: string;
description: string;
probability: number; // 0-1
impact: number; // 0-1
risk_score: number;
mitigation: string[];
contingency: string[];
owner: string;
timeline: string;
}
export interface PlanningRecommendation {
id: string;
type: 'optimization' | 'risk_mitigation' | 'alternative' | 'enhancement';
description: string;
rationale: string;
impact: string;
effort: string;
priority: 'low' | 'medium' | 'high' | 'critical';
}
export interface PlanValidation {
status: 'valid' | 'warnings' | 'errors';
checks: ValidationCheck[];
reality_checks: RealityValidation[];
consistency_checks: ConsistencyCheck[];
completeness_score: number; // 0-1
feasibility_score: number; // 0-1
}
export interface ValidationCheck {
id: string;
category: string;
description: string;
status: 'passed' | 'warning' | 'failed';
message: string;
recommendations: string[];
}
export interface RealityValidation {
aspect: string;
realistic: boolean;
evidence: string[];
concerns: string[];
alternatives: string[];
}
export interface ConsistencyCheck {
areas: string[];
consistent: boolean;
conflicts: string[];
resolution: string[];
}
export interface ProjectEstimation {
effort: EffortEstimation;
timeline: TimelineEstimation;
cost: CostEstimation;
resources: ResourceEstimation;
confidence: EstimationConfidence;
}
export interface EffortEstimation {
total_hours: number;
breakdown: EffortBreakdown[];
methodology: string;
assumptions: string[];
risks: string[];
}
export interface EffortBreakdown {
category: string;
hours: number;
confidence: number; // 0-1
assumptions: string[];
}
export interface TimelineEstimation {
duration: string;
start_date: string;
end_date: string;
critical_path: string[];
dependencies: string[];
buffer: number; // percentage
}
export interface CostEstimation {
total_cost: number;
currency: string;
breakdown: CostBreakdown[];
assumptions: string[];
risks: string[];
}
export interface CostBreakdown {
category: string;
cost: number;
recurring: boolean;
frequency?: string;
}
export interface ResourceEstimation {
roles: RoleEstimation[];
skills: SkillEstimation[];
tools: ToolEstimation[];
infrastructure: InfrastructureEstimation[];
}
export interface RoleEstimation {
role: string;
count: number;
duration: string;
cost: number;
availability: string;
}
export interface SkillEstimation {
skill: string;
level: string;
demand: number; // hours
availability: string;
alternatives: string[];
}
export interface ToolEstimation {
tool: string;
licenses: number;
cost: number;
alternatives: string[];
}
export interface InfrastructureEstimation {
component: string;
specification: string;
cost: number;
scaling: string;
}
export interface EstimationConfidence {
overall: number; // 0-1
effort: number; // 0-1
timeline: number; // 0-1
cost: number; // 0-1
factors: ConfidenceFactor[];
}
export interface ConfidenceFactor {
factor: string;
impact: 'positive' | 'negative';
magnitude: 'low' | 'medium' | 'high';
description: string;
}
export interface NextStep {
id: string;
action: string;
description: string;
owner: string;
due_date: string;
dependencies: string[];
deliverables: string[];
priority: 'low' | 'medium' | 'high' | 'critical';
}
export interface ApprovalRequirement {
id: string;
type: 'plan' | 'architecture' | 'budget' | 'timeline' | 'resources';
approver: string;
criteria: string[];
documentation: string[];
deadline: string;
escalation: string[];
}