datapilot-cli/dist/analyzers/modeling/intelligent-algorithm-selection/types.d.ts

Enterprise-grade streaming multi-format data analysis with comprehensive statistical insights and intelligent relationship detection - supports CSV, JSON, Excel, TSV, Parquet - memory-efficient, cross-platform

/**
 * Intelligent Algorithm Selection Engine - Type Definitions
 * Advanced algorithm selection based on dataset characteristics and business requirements
 */
export interface AlgorithmSelectionProfile {
    selectedAlgorithms: EnhancedAlgorithmRecommendation[];
    selectionReasoning: AlgorithmSelectionReasoning;
    performancePredictions: PerformancePrediction[];
    riskAssessment: AlgorithmRiskAssessment;
    ensembleRecommendations: EnsembleRecommendation[];
    hyperparameterGuidance: HyperparameterOptimizationGuidance;
    implementationStrategy: ImplementationStrategy;
    selectionMetadata: SelectionMetadata;
}
export interface EnhancedAlgorithmRecommendation {
    algorithmName: string;
    algorithmFamily: AlgorithmFamily;
    category: AdvancedAlgorithmCategory;
    suitabilityScore: number;
    complexity: ModelComplexity;
    interpretability: InterpretabilityLevel;
    scoringBreakdown: ScoringBreakdown;
    datasetFitAnalysis: DatasetFitAnalysis;
    expectedPerformance: PerformanceEstimate;
    computationalRequirements: ComputationalRequirements;
    implementationDetails: ImplementationDetails;
    riskFactors: RiskFactor[];
    limitations: AlgorithmLimitation[];
    mitigationStrategies: MitigationStrategy[];
    businessAlignment: BusinessAlignment;
    advancedFeatures: AdvancedFeature[];
    customizationOptions: CustomizationOption[];
}
export type AlgorithmFamily = 'linear_models' | 'tree_based' | 'ensemble_methods' | 'neural_networks' | 'probabilistic_models' | 'instance_based' | 'manifold_learning' | 'kernel_methods' | 'meta_learning' | 'automated_ml';
export type AdvancedAlgorithmCategory = 'classical_ml' | 'modern_ml' | 'deep_learning' | 'ensemble_learning' | 'probabilistic_ml' | 'geometric_ml' | 'evolutionary_ml' | 'quantum_ml' | 'automated_ml' | 'specialized';
export type ModelComplexity = 'simple' | 'moderate' | 'complex' | 'advanced' | 'research_level';
export type InterpretabilityLevel = 'very_high' | 'high' | 'medium' | 'low' | 'very_low' | 'black_box';
export interface ScoringBreakdown {
    dataFitScore: number;
    performanceScore: number;
    interpretabilityScore: number;
    implementationScore: number;
    robustnessScore: number;
    scalabilityScore: number;
    maintenanceScore: number;
    technicalScore: number;
    businessScore: number;
    overallScore: number;
    weightingStrategy: WeightingStrategy;
    confidenceInterval: [number, number];
}
export interface WeightingStrategy {
    weights: ScoringWeights;
    justification: string;
    adaptiveWeighting: boolean;
    uncertaintyHandling: UncertaintyHandling;
}
export interface ScoringWeights {
    dataFit: number;
    performance: number;
    interpretability: number;
    implementation: number;
    robustness: number;
    scalability: number;
    maintenance: number;
}
export interface UncertaintyHandling {
    method: 'conservative' | 'aggressive' | 'balanced' | 'adaptive';
    uncertaintyPenalty: number;
    confidenceThreshold: number;
}
export interface DatasetFitAnalysis {
    complexityAlignment: ComplexityAlignment;
    featureCompatibility: FeatureCompatibility;
    sizeSuitability: SizeSuitability;
    distributionCompatibility: DistributionCompatibility;
    noiseRobustness: NoiseRobustness;
    sparsityHandling: SparsityHandling;
    temporalCompatibility?: TemporalCompatibility;
}
export interface ComplexityAlignment {
    intrinsicComplexityFit: number;
    nonLinearityHandling: number;
    interactionCapturing: number;
    manifoldLearning: number;
    overallAlignment: number;
}
export interface FeatureCompatibility {
    numericFeatureHandling: FeatureHandlingCapability;
    categoricalFeatureHandling: FeatureHandlingCapability;
    textFeatureHandling: FeatureHandlingCapability;
    temporalFeatureHandling: FeatureHandlingCapability;
    mixedTypeHandling: FeatureHandlingCapability;
    highDimensionalitySupport: FeatureHandlingCapability;
}
export interface FeatureHandlingCapability {
    nativeSupport: boolean;
    preprocessingRequired: boolean;
    performanceImpact: 'none' | 'minimal' | 'moderate' | 'significant';
    implementationComplexity: 'simple' | 'moderate' | 'complex';
    recommendations: string[];
}
export interface SizeSuitability {
    optimalSampleSize: SampleSizeRange;
    currentDatasetFit: DatasetSizeFit;
    scalabilityCharacteristics: ScalabilityCharacteristics;
    memoryEfficiency: MemoryEfficiency;
    computationalScaling: ComputationalScaling;
}
export interface SampleSizeRange {
    minimum: number;
    recommended: number;
    optimal: number;
    maximum?: number;
}
export interface DatasetSizeFit {
    fit: 'undersized' | 'adequate' | 'optimal' | 'oversized';
    confidenceImpact: number;
    recommendations: string[];
}
export interface ScalabilityCharacteristics {
    horizontalScalability: ScalabilityLevel;
    verticalScalability: ScalabilityLevel;
    distributedSupport: boolean;
    streamingCapability: boolean;
    incrementalLearning: boolean;
}
export type ScalabilityLevel = 'poor' | 'fair' | 'good' | 'excellent';
export interface MemoryEfficiency {
    memoryComplexity: 'O(1)' | 'O(n)' | 'O(n²)' | 'O(n³)' | 'exponential';
    inMemoryRequirement: boolean;
    diskBasedSupport: boolean;
    streamingSupport: boolean;
    memoryOptimizations: string[];
}
export interface ComputationalScaling {
    trainingComplexity: ComplexityClass;
    predictionComplexity: ComplexityClass;
    parallelizability: ParallelizationCapability;
    hardwareOptimizations: HardwareOptimization[];
}
export type ComplexityClass = 'O(1)' | 'O(log n)' | 'O(n)' | 'O(n log n)' | 'O(n²)' | 'O(n³)' | 'exponential';
export interface ParallelizationCapability {
    trainingParallelization: boolean;
    predictionParallelization: boolean;
    gpuSupport: boolean;
    tpuSupport: boolean;
    distributedTraining: boolean;
}
export interface HardwareOptimization {
    type: 'cpu' | 'gpu' | 'tpu' | 'fpga' | 'quantum';
    supportLevel: 'native' | 'library' | 'experimental' | 'none';
    performanceGain: number;
    requirements: string[];
}
export interface DistributionCompatibility {
    gaussianAssumptions: boolean;
    robustToOutliers: boolean;
    skewnessHandling: SkewnessHandling;
    multimodalSupport: boolean;
    distributionFreeApproach: boolean;
}
export interface SkewnessHandling {
    leftSkewTolerance: number;
    rightSkewTolerance: number;
    transformationRecommendations: string[];
    nativeSkewHandling: boolean;
}
export interface NoiseRobustness {
    noiseResistance: number;
    outlierRobustness: number;
    labelNoiseHandling: number;
    featureNoiseHandling: number;
    robustnessMechanisms: RobustnessMechanism[];
}
export interface RobustnessMechanism {
    mechanism: string;
    effectiveness: number;
    tradeoffs: string[];
    configurationRequired: boolean;
}
export interface SparsityHandling {
    sparseSupport: boolean;
    sparseOptimizations: boolean;
    sparsityThreshold: number;
    densificationRequired: boolean;
    sparsityStrategies: SparsityStrategy[];
}
export interface SparsityStrategy {
    strategy: 'imputation' | 'sparse_algorithms' | 'feature_selection' | 'regularization' | 'embedding';
    applicability: number;
    performanceImpact: number;
    implementationComplexity: 'simple' | 'moderate' | 'complex';
}
export interface TemporalCompatibility {
    timeSeriesSupport: boolean;
    temporalPatternCapture: TemporalPatternCapture;
    forecastingCapability: ForecastingCapability;
    conceptDriftHandling: ConceptDriftHandling;
}
export interface TemporalPatternCapture {
    trendCapture: boolean;
    seasonalityCapture: boolean;
    cyclicalPatternCapture: boolean;
    longTermDependencies: boolean;
    shortTermDependencies: boolean;
}
export interface ForecastingCapability {
    univariateForecast: boolean;
    multivariateForecast: boolean;
    shortTermAccuracy: number;
    longTermAccuracy: number;
    uncertaintyQuantification: boolean;
}
export interface ConceptDriftHandling {
    driftDetection: boolean;
    driftAdaptation: boolean;
    adaptationSpeed: 'fast' | 'moderate' | 'slow';
    forgettingMechanism: boolean;
}
export interface PerformancePrediction {
    algorithmName: string;
    expectedMetrics: ExpectedMetrics;
    confidenceIntervals: ConfidenceIntervals;
    performanceFactors: PerformanceFactor[];
    scenarioAnalysis: ScenarioAnalysis;
    benchmarkComparison: BenchmarkComparison;
}
export interface ExpectedMetrics {
    primaryMetric: MetricPrediction;
    secondaryMetrics: MetricPrediction[];
    businessMetrics: BusinessMetricPrediction[];
    robustnessMetrics: RobustnessMetricPrediction[];
}
export interface MetricPrediction {
    metricName: string;
    expectedValue: number;
    confidenceInterval: [number, number];
    predictionMethod: PredictionMethod;
    reliability: number;
}
export interface PerformanceEstimate {
    accuracy?: number;
    precision?: number;
    recall?: number;
    f1Score?: number;
    rmse?: number;
    mae?: number;
    rSquared?: number;
    confidenceInterval: [number, number];
    performanceFactors: string[];
}
export type PredictionMethod = 'meta_learning' | 'similar_datasets' | 'theoretical_bounds' | 'expert_knowledge' | 'hybrid_approach';
export interface BusinessMetricPrediction {
    metricName: string;
    expectedImpact: number;
    impactType: 'revenue' | 'cost_savings' | 'efficiency' | 'risk_reduction' | 'satisfaction';
    confidenceLevel: number;
    assumptions: string[];
}
export interface RobustnessMetricPrediction {
    metricName: string;
    robustnessScore: number;
    vulnerabilities: string[];
    mitigations: string[];
}
export interface ConfidenceIntervals {
    methodology: 'bootstrap' | 'bayesian' | 'frequentist' | 'ensemble';
    confidenceLevel: number;
    intervalWidth: number;
    asymmetry: number;
}
export interface PerformanceFactor {
    factor: string;
    impact: number;
    importance: number;
    controllability: number;
    mitigation: string[];
}
export interface ScenarioAnalysis {
    bestCase: ScenarioOutcome;
    expectedCase: ScenarioOutcome;
    worstCase: ScenarioOutcome;
    sensitivityAnalysis: SensitivityFactor[];
}
export interface ScenarioOutcome {
    scenario: string;
    probability: number;
    expectedPerformance: number;
    keyFactors: string[];
    implications: string[];
}
export interface SensitivityFactor {
    factor: string;
    sensitivity: number;
    threshold: number;
    recommendation: string;
}
export interface BenchmarkComparison {
    similarDatasets: SimilarDatasetBenchmark[];
    industryBenchmarks: IndustryBenchmark[];
    theoreticalLimits: TheoreticalLimit[];
    relativeRanking: RelativeRanking;
}
export interface SimilarDatasetBenchmark {
    datasetCharacteristics: DatasetCharacteristics;
    algorithmPerformance: AlgorithmPerformance[];
    similarity: number;
    transferability: number;
}
export interface DatasetCharacteristics {
    size: number;
    features: number;
    complexity: number;
    domain: string;
    taskType: string;
}
export interface AlgorithmPerformance {
    algorithmName: string;
    performance: number;
    trainingTime: number;
    implementation: string;
    notes: string[];
}
export interface IndustryBenchmark {
    industry: string;
    problemType: string;
    typicalPerformance: PerformanceRange;
    bestPractices: string[];
    commonPitfalls: string[];
}
export interface PerformanceRange {
    minimum: number;
    average: number;
    maximum: number;
    percentiles: PerformileDistribution;
}
export interface PerformileDistribution {
    p25: number;
    p50: number;
    p75: number;
    p90: number;
    p95: number;
}
export interface TheoreticalLimit {
    limitType: 'bayes_optimal' | 'information_theoretic' | 'computational' | 'statistical';
    limitValue: number;
    assumptions: string[];
    achievability: number;
}
export interface RelativeRanking {
    algorithmRankings: AlgorithmRanking[];
    rankingCriteria: RankingCriterion[];
    rankingConfidence: number;
    rankingStability: number;
}
export interface AlgorithmRanking {
    algorithmName: string;
    rank: number;
    score: number;
    strengths: string[];
    weaknesses: string[];
}
export interface RankingCriterion {
    criterion: string;
    weight: number;
    justification: string;
}
export interface AlgorithmSelectionReasoning {
    selectionCriteria: SelectionCriterion[];
    decisionTree: DecisionTreeNode;
    alternativeConsiderations: AlternativeConsideration[];
    selectionConfidence: SelectionConfidence;
    assumptions: SelectionAssumption[];
    sensitivityAnalysis: SelectionSensitivityAnalysis;
}
export interface SelectionCriterion {
    criterion: string;
    weight: number;
    satisfaction: number;
    criticality: 'must_have' | 'important' | 'nice_to_have';
    tradeoffs: string[];
}
export interface DecisionTreeNode {
    decision: string;
    reasoning: string;
    alternatives: AlternativeOption[];
    children?: DecisionTreeNode[];
    confidence: number;
}
export interface AlternativeOption {
    option: string;
    pros: string[];
    cons: string[];
    score: number;
    selected: boolean;
}
export interface AlternativeConsideration {
    algorithmName: string;
    reasonForExclusion: string;
    alternativeScore: number;
    reconsiderationTriggers: string[];
}
export interface SelectionConfidence {
    overallConfidence: number;
    confidenceFactors: ConfidenceFactor[];
    uncertaintySource: string[];
    robustnessToAssumptions: number;
}
export interface ConfidenceFactor {
    factor: string;
    contribution: number;
    importance: number;
    mitigation: string[];
}
export interface SelectionAssumption {
    assumption: string;
    validity: number;
    impact: number;
    verification: string[];
}
export interface SelectionSensitivityAnalysis {
    parameterSensitivity: ParameterSensitivity[];
    assumptionSensitivity: AssumptionSensitivity[];
    dataCharacteristicSensitivity: DataCharacteristicSensitivity[];
}
export interface ParameterSensitivity {
    parameter: string;
    sensitivity: number;
    criticalRange: [number, number];
    recommendations: string[];
}
export interface AssumptionSensitivity {
    assumption: string;
    violationImpact: number;
    detectionMethods: string[];
    contingencyPlans: string[];
}
export interface DataCharacteristicSensitivity {
    characteristic: string;
    sensitivityLevel: number;
    thresholds: DataThreshold[];
    adaptationStrategies: string[];
}
export interface DataThreshold {
    threshold: number;
    implication: string;
    recommendedAction: string;
}
export interface AlgorithmRiskAssessment {
    overallRiskLevel: RiskLevel;
    riskCategories: RiskCategory[];
    mitigationPlan: MitigationPlan;
    contingencyStrategies: ContingencyStrategy[];
    monitoringPlan: RiskMonitoringPlan;
}
export type RiskLevel = 'very_low' | 'low' | 'medium' | 'high' | 'very_high';
export interface RiskCategory {
    category: RiskCategoryType;
    riskLevel: RiskLevel;
    riskFactors: RiskFactor[];
    likelihood: number;
    impact: number;
    detectability: number;
}
export type RiskCategoryType = 'performance_risk' | 'implementation_risk' | 'maintenance_risk' | 'scalability_risk' | 'interpretability_risk' | 'business_risk' | 'technical_debt_risk' | 'compliance_risk';
export interface RiskFactor {
    factor: string;
    severity: RiskLevel;
    probability: number;
    timeframe: 'immediate' | 'short_term' | 'medium_term' | 'long_term';
    dependencies: string[];
    indicators: string[];
}
export interface MitigationPlan {
    primaryMitigations: MitigationStrategy[];
    secondaryMitigations: MitigationStrategy[];
    preventiveMeasures: PreventiveMeasure[];
    contingencyPlans: ContingencyPlan[];
}
export interface MitigationStrategy {
    strategy: string;
    applicability: string[];
    effectiveness: number;
    implementationCost: 'low' | 'medium' | 'high';
    timeToImplement: number;
    dependencies: string[];
}
export interface PreventiveMeasure {
    measure: string;
    targetRisks: string[];
    implementation: string;
    cost: 'low' | 'medium' | 'high';
    effectiveness: number;
}
export interface ContingencyPlan {
    trigger: string;
    actions: ContingencyAction[];
    fallbackOptions: FallbackOption[];
    decisionCriteria: string[];
}
export interface ContingencyAction {
    action: string;
    priority: number;
    timeframe: string;
    resources: string[];
    successCriteria: string[];
}
export interface FallbackOption {
    option: string;
    performanceImpact: number;
    implementationEffort: 'low' | 'medium' | 'high';
    viability: number;
}
export interface ContingencyStrategy {
    scenario: string;
    strategy: string;
    triggers: string[];
    implementation: string[];
    rollbackPlan: string[];
}
export interface RiskMonitoringPlan {
    monitoringMetrics: MonitoringMetric[];
    alertThresholds: AlertThreshold[];
    reviewSchedule: ReviewSchedule;
    escalationProcedures: EscalationProcedure[];
}
export interface MonitoringMetric {
    metric: string;
    purpose: string;
    frequency: 'real_time' | 'hourly' | 'daily' | 'weekly' | 'monthly';
    threshold: number;
    action: string;
}
export interface AlertThreshold {
    metric: string;
    warningThreshold: number;
    criticalThreshold: number;
    responseTime: number;
    responsibleParty: string;
}
export interface ReviewSchedule {
    frequency: 'weekly' | 'monthly' | 'quarterly' | 'annually';
    scope: string[];
    participants: string[];
    deliverables: string[];
}
export interface EscalationProcedure {
    level: number;
    trigger: string;
    timeframe: number;
    actions: string[];
    authority: string;
}
export interface ImplementationDetails {
    frameworks: FrameworkSupport[];
    libraries: LibraryRecommendation[];
    dependencies: DependencyRequirement[];
    configuration: ConfigurationGuidance;
    deployment: DeploymentConsiderations;
}
export interface FrameworkSupport {
    framework: string;
    supportLevel: 'native' | 'plugin' | 'community' | 'custom';
    maturity: 'experimental' | 'beta' | 'stable' | 'mature';
    documentation: 'poor' | 'fair' | 'good' | 'excellent';
    communitySize: 'small' | 'medium' | 'large';
}
export interface LibraryRecommendation {
    library: string;
    version: string;
    purpose: string;
    alternatives: string[];
    pros: string[];
    cons: string[];
}
export interface DependencyRequirement {
    dependency: string;
    version: string;
    optional: boolean;
    purpose: string;
    installationComplexity: 'simple' | 'moderate' | 'complex';
}
export interface ConfigurationGuidance {
    requiredParameters: ConfigurationParameter[];
    optionalParameters: ConfigurationParameter[];
    tuningPriority: TuningPriority[];
    bestPractices: string[];
}
export interface ConfigurationParameter {
    parameter: string;
    type: 'number' | 'string' | 'boolean' | 'array' | 'object';
    defaultValue: any;
    range?: [number, number];
    options?: string[];
    description: string;
    impact: 'low' | 'medium' | 'high';
}
export interface TuningPriority {
    parameter: string;
    priority: number;
    tuningMethod: 'grid_search' | 'random_search' | 'bayesian' | 'manual';
    effort: 'low' | 'medium' | 'high';
    expectedGain: number;
}
export interface DeploymentConsiderations {
    deploymentPatterns: DeploymentPattern[];
    infrastructureRequirements: InfrastructureRequirement[];
    scalingConsiderations: ScalingConsideration[];
    maintenanceRequirements: MaintenanceRequirement[];
}
export interface DeploymentPattern {
    pattern: 'batch' | 'real_time' | 'streaming' | 'edge' | 'hybrid';
    suitability: number;
    considerations: string[];
    implementation: string[];
}
export interface InfrastructureRequirement {
    component: string;
    requirement: string;
    criticality: 'required' | 'recommended' | 'optional';
    alternatives: string[];
}
export interface ScalingConsideration {
    dimension: 'data_volume' | 'user_load' | 'feature_count' | 'model_complexity';
    scalingStrategy: string;
    limitations: string[];
    costImplications: string[];
}
export interface MaintenanceRequirement {
    task: string;
    frequency: string;
    effort: 'low' | 'medium' | 'high';
    automation: 'fully_automated' | 'semi_automated' | 'manual';
    skillsRequired: string[];
}
export interface ComputationalRequirements {
    trainingRequirements: ResourceRequirement;
    predictionRequirements: ResourceRequirement;
    storageRequirements: StorageRequirement;
    networkRequirements: NetworkRequirement;
}
export interface ResourceRequirement {
    cpu: CpuRequirement;
    memory: MemoryRequirement;
    gpu?: GpuRequirement;
    timeComplexity: string;
    parallelization: ParallelizationSupport;
}
export interface CpuRequirement {
    cores: number;
    architecture: string[];
    specialInstructions: string[];
    utilization: number;
}
export interface MemoryRequirement {
    minimum: number;
    recommended: number;
    scaling: 'constant' | 'linear' | 'quadratic' | 'exponential';
    pattern: 'in_memory' | 'streaming' | 'disk_based';
}
export interface GpuRequirement {
    required: boolean;
    memory: number;
    computeCapability: string;
    frameworks: string[];
    expectedSpeedup: number;
}
export interface ParallelizationSupport {
    dataParallelism: boolean;
    modelParallelism: boolean;
    maxWorkers: number;
    efficiency: number;
}
export interface StorageRequirement {
    modelSize: number;
    temporaryStorage: number;
    dataFormat: string[];
    compressionSupport: boolean;
}
export interface NetworkRequirement {
    bandwidth: number;
    latency: number;
    reliability: number;
    distributedSupport: boolean;
}
export interface AlgorithmLimitation {
    limitation: string;
    severity: 'minor' | 'moderate' | 'major' | 'critical';
    affectedScenarios: string[];
    workarounds: string[];
    fundamentalLimitation: boolean;
}
export interface BusinessAlignment {
    businessObjectives: BusinessObjective[];
    stakeholderRequirements: StakeholderRequirement[];
    constraintCompliance: ConstraintCompliance[];
    valueProposition: ValueProposition;
}
export interface BusinessObjective {
    objective: string;
    alignment: number;
    contribution: string;
    measurability: string;
    timeframe: string;
}
export interface StakeholderRequirement {
    stakeholder: string;
    requirement: string;
    satisfaction: number;
    criticality: 'must_have' | 'should_have' | 'nice_to_have';
    tradeoffs: string[];
}
export interface ConstraintCompliance {
    constraint: string;
    complianceLevel: number;
    gapAnalysis: string[];
    mitigationPlan: string[];
}
export interface ValueProposition {
    primaryValue: string;
    quantifiableVBenefits: QuantifiableBenefit[];
    qualitativeBenefits: string[];
    investmentRequired: InvestmentRequirement;
    roi: ROIAnalysis;
}
export interface QuantifiableBenefit {
    benefit: string;
    metric: string;
    expectedValue: number;
    confidenceLevel: number;
    timeframe: string;
}
export interface InvestmentRequirement {
    initialInvestment: number;
    ongoingCosts: number;
    resourceRequirements: string[];
    timeInvestment: number;
}
export interface ROIAnalysis {
    expectedROI: number;
    paybackPeriod: number;
    netPresentValue: number;
    riskAdjustedROI: number;
    assumptions: string[];
}
export interface AdvancedFeature {
    feature: string;
    description: string;
    benefit: string;
    implementationComplexity: 'simple' | 'moderate' | 'complex';
    maturity: 'experimental' | 'beta' | 'stable';
    documentation: string;
}
export interface CustomizationOption {
    option: string;
    purpose: string;
    flexibility: number;
    complexity: 'simple' | 'moderate' | 'complex';
    impact: string;
    examples: string[];
}
export interface EnsembleRecommendation {
    ensembleType: EnsembleType;
    baseModels: BaseModelRecommendation[];
    combinationStrategy: CombinationStrategy;
    expectedImprovement: number;
    implementationComplexity: ModelComplexity;
    diversityAnalysis: DiversityAnalysis;
    ensembleMetrics: EnsembleMetrics;
}
export type EnsembleType = 'bagging' | 'boosting' | 'stacking' | 'blending' | 'voting' | 'multi_level' | 'dynamic_ensemble' | 'meta_ensemble';
export interface BaseModelRecommendation {
    algorithmName: string;
    role: 'primary' | 'specialist' | 'diversity' | 'calibration' | 'robustness';
    weight: number;
    contribution: string;
    strengths: string[];
    hyperparameterStrategy: string;
}
export interface CombinationStrategy {
    method: 'averaging' | 'weighted_average' | 'voting' | 'stacking' | 'blending' | 'dynamic';
    parameters: any;
    adaptivity: boolean;
    confidence: number;
}
export interface DiversityAnalysis {
    diversityMetrics: DiversityMetric[];
    optimalDiversity: number;
    diversityStrategies: DiversityStrategy[];
    diversityMaintenance: string[];
}
export interface DiversityMetric {
    metric: string;
    value: number;
    interpretation: string;
    target: number;
}
export interface DiversityStrategy {
    strategy: string;
    effectiveness: number;
    implementation: string;
    tradeoffs: string[];
}
export interface EnsembleMetrics {
    biasVarianceTradeoff: BiasVarianceAnalysis;
    stabilityAnalysis: StabilityAnalysis;
    calibrationAnalysis: CalibrationAnalysis;
    uncertaintyQuantification: UncertaintyQuantification;
}
export interface BiasVarianceAnalysis {
    biasReduction: number;
    varianceReduction: number;
    overallImprovement: number;
    optimalComplexity: string;
}
export interface StabilityAnalysis {
    predictionStability: number;
    rankingStability: number;
    robustnessToData: number;
    stabilityFactors: string[];
}
export interface CalibrationAnalysis {
    calibrationScore: number;
    overconfidence: number;
    underconfidence: number;
    calibrationMethods: string[];
}
export interface UncertaintyQuantification {
    uncertaintyType: 'aleatoric' | 'epistemic' | 'both';
    quantificationMethod: string;
    reliability: number;
    coverage: number;
}
export interface HyperparameterOptimizationGuidance {
    optimizationStrategy: OptimizationStrategy;
    parameterImportance: ParameterImportanceRanking[];
    searchSpaceDefinition: SearchSpaceDefinition;
    optimizationBudget: OptimizationBudget;
    multiObjectiveConsiderations: MultiObjectiveOptimization;
    transferLearningOpportunities: TransferLearningOpportunity[];
}
export interface OptimizationStrategy {
    primaryMethod: OptimizationMethod;
    fallbackMethods: OptimizationMethod[];
    multiPhaseStrategy: OptimizationPhase[];
    earlyStoppingCriteria: EarlyStoppingCriterion[];
    warmStartingStrategy: WarmStartingStrategy;
}
export type OptimizationMethod = 'grid_search' | 'random_search' | 'bayesian_optimization' | 'evolutionary_algorithms' | 'population_based_training' | 'hyperband' | 'optuna' | 'multi_fidelity' | 'neural_architecture_search';
export interface OptimizationPhase {
    phase: string;
    method: OptimizationMethod;
    budget: number;
    focus: string[];
    successCriteria: string[];
}
export interface EarlyStoppingCriterion {
    criterion: string;
    threshold: number;
    patience: number;
    monitor: string;
}
export interface WarmStartingStrategy {
    strategy: string;
    sourceData: string[];
    transferability: number;
    adaptation: string[];
}
export interface ParameterImportanceRanking {
    parameter: string;
    importance: number;
    sensitivityAnalysis: ParameterSensitivityAnalysis;
    interactionEffects: ParameterInteraction[];
    tuningRecommendations: TuningRecommendation[];
}
export interface ParameterSensitivityAnalysis {
    sensitivity: number;
    optimalRange: [number, number];
    defaultPerformance: number;
    maxImprovement: number;
    robustness: number;
}
export interface ParameterInteraction {
    otherParameter: string;
    interactionStrength: number;
    interactionType: 'synergistic' | 'antagonistic' | 'neutral';
    jointOptimizationBenefit: number;
}
export interface TuningRecommendation {
    recommendation: string;
    priority: 'high' | 'medium' | 'low';
    expectedImprovement: number;
    effort: 'low' | 'medium' | 'high';
    riskLevel: 'low' | 'medium' | 'high';
}
export interface SearchSpaceDefinition {
    continuousParameters: ContinuousParameter[];
    discreteParameters: DiscreteParameter[];
    categoricalParameters: CategoricalParameter[];
    conditionalParameters: ConditionalParameter[];
    constraints: ParameterConstraint[];
}
export interface ContinuousParameter {
    name: string;
    type: 'float' | 'int';
    min: number;
    max: number;
    scale: 'linear' | 'log' | 'uniform';
    default: number;
    prior?: PriorDistribution;
}
export interface DiscreteParameter {
    name: string;
    values: number[];
    default: number;
    distribution?: number[];
}
export interface CategoricalParameter {
    name: string;
    choices: string[];
    default: string;
    probabilities?: number[];
}
export interface ConditionalParameter {
    name: string;
    condition: ParameterCondition;
    parameter: ContinuousParameter | DiscreteParameter | CategoricalParameter;
}
export interface ParameterCondition {
    parentParameter: string;
    operator: 'equals' | 'not_equals' | 'greater' | 'less' | 'in' | 'not_in';
    value: any;
}
export interface ParameterConstraint {
    type: 'linear' | 'nonlinear' | 'logical';
    expression: string;
    parameters: string[];
    violation: 'warning' | 'error';
}
export interface PriorDistribution {
    distribution: 'normal' | 'uniform' | 'beta' | 'gamma' | 'exponential';
    parameters: number[];
    confidence: number;
}
export interface OptimizationBudget {
    totalEvaluations: number;
    parallelEvaluations: number;
    timeLimit: number;
    computeResources: ComputeResourceBudget;
    costLimit?: number;
    adaptiveBudgetAllocation: boolean;
}
export interface ComputeResourceBudget {
    cpuHours: number;
    gpuHours?: number;
    memoryGB: number;
    storageGB: number;
    networkBandwidth?: number;
}
export interface MultiObjectiveOptimization {
    objectives: OptimizationObjective[];
    tradeoffAnalysis: TradeoffAnalysis;
    paretoOptimization: ParetoOptimization;
    scalarization: ScalarizationStrategy;
}
export interface OptimizationObjective {
    name: string;
    type: 'maximize' | 'minimize';
    weight: number;
    priority: number;
    constraint?: ObjectiveConstraint;
}
export interface ObjectiveConstraint {
    type: 'threshold' | 'range';
    value: number | [number, number];
    hard: boolean;
}
export interface TradeoffAnalysis {
    objectivePairs: ObjectivePairAnalysis[];
    tradeoffStrength: number;
    dominantObjectives: string[];
    compromiseSolutions: CompromiseSolution[];
}
export interface ObjectivePairAnalysis {
    objective1: string;
    objective2: string;
    correlation: number;
    conflictLevel: number;
    resolutionStrategies: string[];
}
export interface CompromiseSolution {
    solution: string;
    objectiveValues: number[];
    satisfactionLevel: number;
    stakeholderAcceptance: number;
}
export interface ParetoOptimization {
    enabled: boolean;
    frontierSize: number;
    diversityMaintenance: boolean;
    convergenceMetrics: ConvergenceMetric[];
}
export interface ConvergenceMetric {
    metric: string;
    target: number;
    currentValue: number;
    trend: 'improving' | 'stable' | 'degrading';
}
export interface ScalarizationStrategy {
    method: 'weighted_sum' | 'epsilon_constraint' | 'goal_programming' | 'chebyshev';
    parameters: any;
    adaptiveWeights: boolean;
    robustness: number;
}
export interface TransferLearningOpportunity {
    sourceDataset: string;
    similarity: number;
    transferableParameters: string[];
    expectedImprovement: number;
    transferMethod: TransferMethod;
}
export interface TransferMethod {
    method: 'direct_transfer' | 'fine_tuning' | 'meta_learning' | 'domain_adaptation';
    adaptationRequired: boolean;
    effort: 'low' | 'medium' | 'high';
    success: 'likely' | 'moderate' | 'uncertain';
}
export interface ImplementationStrategy {
    phaseAPproach: ImplementationPhase[];
    riskMitigation: ImplementationRiskMitigation;
    resourcePlanning: ResourcePlanning;
    timeline: ImplementationTimeline;
    qualityAssurance: QualityAssuranceStrategy;
    rolloutStrategy: RolloutStrategy;
}
export interface ImplementationPhase {
    phase: string;
    objectives: string[];
    deliverables: string[];
    duration: number;
    dependencies: string[];
    riskLevel: RiskLevel;
    successCriteria: string[];
}
export interface ImplementationRiskMitigation {
    identifiedRisks: ImplementationRisk[];
    mitigationStrategies: ImplementationMitigationStrategy[];
    contingencyPlans: ImplementationContingencyPlan[];
    monitoring: RiskMonitoringStrategy;
}
export interface ImplementationRisk {
    risk: string;
    likelihood: number;
    impact: number;
    phase: string;
    mitigation: string[];
}
export interface ImplementationMitigationStrategy {
    strategy: string;
    applicableRisks: string[];
    effectiveness: number;
    cost: 'low' | 'medium' | 'high';
    timeline: number;
}
export interface ImplementationContingencyPlan {
    trigger: string;
    actions: string[];
    fallbackOptions: string[];
    decisionTimeframe: number;
}
export interface RiskMonitoringStrategy {
    monitoringPoints: MonitoringPoint[];
    escalationProcedures: string[];
    reviewFrequency: string;
    responsibilityMatrix: ResponsibilityAssignment[];
}
export interface MonitoringPoint {
    phase: string;
    metrics: string[];
    thresholds: number[];
    frequency: string;
    responsible: string;
}
export interface ResponsibilityAssignment {
    role: string;
    responsibilities: string[];
    authority: string[];
    escalationPath: string[];
}
export interface ResourcePlanning {
    humanResources: HumanResourceRequirement[];
    technicalResources: TechnicalResourceRequirement[];
    budgetEstimate: BudgetEstimate;
    resourceTimeline: ResourceTimeline;
}
export interface HumanResourceRequirement {
    role: string;
    skillsRequired: string[];
    experienceLevel: 'junior' | 'mid' | 'senior' | 'expert';
    timeCommitment: number;
    duration: number;
    availability: 'full_time' | 'part_time' | 'consultant';
}
export interface TechnicalResourceRequirement {
    resource: string;
    specification: string;
    quantity: number;
    duration: number;
    cost: number;
    alternatives: string[];
}
export interface BudgetEstimate {
    totalCost: number;
    costBreakdown: CostComponent[];
    confidenceLevel: number;
    contingencyFactor: number;
    costRange: [number, number];
}
export interface CostComponent {
    component: string;
    cost: number;
    category: 'labor' | 'technology' | 'infrastructure' | 'training' | 'other';
    confidence: number;
}
export interface ResourceTimeline {
    milestones: ResourceMilestone[];
    criticalPath: string[];
    buffers: TimeBuffer[];
    dependencies: ResourceDependency[];
}
export interface ResourceMilestone {
    milestone: string;
    date: Date;
    dependencies: string[];
    deliverables: string[];
    approvals: string[];
}
export interface TimeBuffer {
    phase: string;
    bufferDays: number;
    justification: string;
    triggers: string[];
}
export interface ResourceDependency {
    dependent: string;
    prerequisite: string;
    type: 'hard' | 'soft';
    lead: number;
}
export interface ImplementationTimeline {
    totalDuration: number;
    phases: PhaseTimeline[];
    criticalMilestones: CriticalMilestone[];
    buffers: TimeBuffer[];
    parallelActivities: ParallelActivity[];
}
export interface PhaseTimeline {
    phase: string;
    startDate: Date;
    endDate: Date;
    duration: number;
    predecessors: string[];
    successors: string[];
}
export interface CriticalMilestone {
    milestone: string;
    date: Date;
    criticality: 'critical' | 'important' | 'desirable';
    impact: string;
    contingency: string[];
}
export interface ParallelActivity {
    activities: string[];
    coordination: string[];
    conflictResolution: string[];
    synchronization: string[];
}
export interface QualityAssuranceStrategy {
    qualityStandards: QualityStandard[];
    testingStrategy: TestingStrategy;
    reviewProcesses: ReviewProcess[];
    validationCriteria: ValidationCriterion[];
}
export interface QualityStandard {
    standard: string;
    description: string;
    measurability: string[];
    compliance: string[];
    verification: string[];
}
export interface TestingStrategy {
    testingPhases: TestingPhase[];
    testingTypes: TestingType[];
    automationLevel: number;
    coverageTargets: CoverageTarget[];
}
export interface TestingPhase {
    phase: string;
    objectives: string[];
    methods: string[];
    criteria: string[];
    timeline: number;
}
export interface TestingType {
    type: 'unit' | 'integration' | 'system' | 'performance' | 'security' | 'usability';
    coverage: number;
    automation: boolean;
    frequency: string;
}
export interface CoverageTarget {
    area: string;
    target: number;
    measurement: string;
    tools: string[];
}
export interface ReviewProcess {
    process: string;
    frequency: string;
    participants: string[];
    criteria: string[];
    deliverables: string[];
}
export interface ValidationCriterion {
    criterion: string;
    measurement: string;
    threshold: number;
    importance: 'critical' | 'important' | 'desirable';
}
export interface RolloutStrategy {
    rolloutPhases: RolloutPhase[];
    rolloutCriteria: RolloutCriterion[];
    rollbackPlan: RollbackPlan;
    userAcceptance: UserAcceptanceStrategy;
}
export interface RolloutPhase {
    phase: string;
    scope: string[];
    duration: number;
    prerequisites: string[];
    success: string[];
    monitoring: string[];
}
export interface RolloutCriterion {
    criterion: string;
    threshold: number;
    measurement: string;
    frequency: string;
}
export interface RollbackPlan {
    triggers: string[];
    procedures: string[];
    timeframe: number;
    dataProtection: string[];
    communication: string[];
}
export interface UserAcceptanceStrategy {
    userGroups: UserGroup[];
    acceptanceCriteria: UserAcceptanceCriterion[];
    training: TrainingPlan;
    support: SupportPlan;
}
export interface UserGroup {
    group: string;
    size: number;
    characteristics: string[];
    requirements: string[];
    concerns: string[];
}
export interface UserAcceptanceCriterion {
    criterion: string;
    measurement: string;
    target: number;
    userGroup: string;
}
export interface TrainingPlan {
    trainingModules: TrainingModule[];
    deliveryMethods: string[];
    timeline: number;
    assessment: string[];
}
export interface TrainingModule {
    module: string;
    duration: number;
    audience: string[];
    objectives: string[];
    materials: string[];
}
export interface SupportPlan {
    supportChannels: SupportChannel[];
    escalationProcedures: string[];
    knowledgeBase: string[];
    feedbackMechanisms: string[];
}
export interface SupportChannel {
    channel: string;
    availability: string;
    response: number;
    capacity: number;
}
export interface SelectionMetadata {
    selectionTimestamp: Date;
    selectionVersion: string;
    computationTime: number;
    dataCharacteristics: DatasetCharacteristicsSnapshot;
    selectionConfidence: number;
    assumptions: string[];
    limitations: string[];
    reproducibilityInfo: SelectionReproducibilityInfo;
}
export interface DatasetCharacteristicsSnapshot {
    size: number;
    features: number;
    complexity: number;
    quality: number;
    domain: string;
    taskType: string;
}
export interface SelectionReproducibilityInfo {
    randomSeed?: number;
    softwareVersions: SoftwareVersionInfo[];
    configurationParameters: any;
    environmentInfo: EnvironmentInfo;
    deterministicSelection: boolean;
}
export interface SoftwareVersionInfo {
    package: string;
    version: string;
    purpose: string;
    critical: boolean;
}
export interface EnvironmentInfo {
    platform: string;
    architecture: string;
    runtime: string;
    dependencies: string[];
}
export interface AlgorithmSelectionConfig {
    selectionCriteria: SelectionCriteriaConfig;
    performancePrediction: PerformancePredictionConfig;
    riskTolerance: RiskToleranceConfig;
    implementationConstraints: ImplementationConstraintsConfig;
    businessRequirements: BusinessRequirementsConfig;
    computationalBudget: ComputationalBudgetConfig;
}
export interface SelectionCriteriaConfig {
    primaryCriteria: string[];
    weights: CriteriaWeights;
    weightingStrategy: 'fixed' | 'adaptive' | 'context_dependent';
    tradeoffAcceptance: TradeoffAcceptance;
}
export interface CriteriaWeights {
    performance: number;
    interpretability: number;
    implementation: number;
    maintenance: number;
    robustness: number;
    scalability: number;
}
export interface TradeoffAcceptance {
    performanceForInterpretability: number;
    implementationForPerformance: number;
    robustnessForComplexity: number;
    customTradeoffs: CustomTradeoff[];
}
export interface CustomTradeoff {
    tradeoff: string;
    acceptance: number;
    conditions: string[];
}
export interface PerformancePredictionConfig {
    predictionMethods: PredictionMethodConfig[];
    confidenceRequirements: ConfidenceRequirementsConfig;
    benchmarkingStrategy: BenchmarkingStrategyConfig;
    uncertaintyHandling: UncertaintyHandlingConfig;
}
export interface PredictionMethodConfig {
    method: PredictionMethod;
    weight: number;
    applicabilityConditions: string[];
    fallbackMethods: PredictionMethod[];
}
export interface ConfidenceRequirementsConfig {
    minimumConfidence: number;
    criticalMetrics: string[];
    uncertaintyTolerance: number;
    conservatismLevel: number;
}
export interface BenchmarkingStrategyConfig {
    includeSimilarDatasets: boolean;
    includeIndustryBenchmarks: boolean;
    includeTheoreticalLimits: boolean;
    similarityThreshold: number;
}
export interface UncertaintyHandlingConfig {
    propagationMethod: 'monte_carlo' | 'analytical' | 'bootstrap' | 'bayesian';
    samplingSize: number;
    confidenceLevel: number;
    uncertaintyVisualization: boolean;
}
export interface RiskToleranceConfig {
    overallRiskTolerance: RiskLevel;
    categorySpecificTolerance: CategoryRiskTolerance[];
    riskMitigationPreference: RiskMitigationPreference;
    contingencyPlanning: ContingencyPlanningConfig;
}
export interface CategoryRiskTolerance {
    category: RiskCategoryType;
    tolerance: RiskLevel;
    justification: string;
    monitoring: string[];
}
export interface RiskMitigationPreference {
    preventive: number;
    reactive: number;
    riskTransfer: number;
    riskAcceptance: number;
}
export interface ContingencyPlanningConfig {
    planningHorizon: number;
    scenarioPlanning: boolean;
    contingencyBudget: number;
    decisionFramework: string[];
}
export interface ImplementationConstraintsConfig {
    timeConstraints: TimeConstraintsConfig;
    resourceConstraints: ResourceConstraintsConfig;
    technicalConstraints: TechnicalConstraintsConfig;
    organizationalConstraints: OrganizationalConstraintsConfig;
}
export interface TimeConstraintsConfig {
    maxImplementationTime: number;
    phaseDeadlines: PhaseDeadline[];
    timeBuffers: number;
    accelerationOptions: AccelerationOption[];
}
export interface PhaseDeadline {
    phase: string;
    deadline: Date;
    flexibility: number;
    criticality: 'hard' | 'soft';
}
export interface AccelerationOption {
    option: string;
    timeReduction: number;
    additionalCost: number;
    riskIncrease: number;
}
export interface ResourceConstraintsConfig {
    budgetConstraints: BudgetConstraintsConfig;
    humanResourceConstraints: HumanResourceConstraintsConfig;
    technicalResourceConstraints: TechnicalResourceConstraintsConfig;
    externalResourceConstraints: ExternalResourceConstraintsConfig;
}
export interface BudgetConstraintsConfig {
    totalBudget: number;
    budgetPhasing: BudgetPhasing[];
    contingencyPercentage: number;
    flexibilityRanges: FlexibilityRange[];
}
export interface BudgetPhasing {
    phase: string;
    allocation: number;
    flexibility: number;
    dependencies: string[];
}
export interface FlexibilityRange {
    category: string;
    minBudget: number;
    maxBudget: number;
    implications: string[];
}
export interface HumanResourceConstraintsConfig {
    availableRoles: AvailableRole[];
    skillConstraints: SkillConstraint[];
    trainingBudget: number;
    externalConsultingBudget: number;
}
export interface AvailableRole {
    role: string;
    availability: number;
    skillLevel: 'junior' | 'mid' | 'senior' | 'expert';
    cost: number;
}
export interface SkillConstraint {
    skill: string;
    required: boolean;
    currentLevel: number;
    targetLevel: number;
    developmentTime: number;
}
export interface TechnicalResourceConstraintsConfig {
    computingResources: ComputingResourceConstraints;
    softwareLicenses: SoftwareLicenseConstraints;
    dataAccessConstraints: DataAccessConstraints;
    securityConstraints: SecurityConstraints;
}
export interface ComputingResourceConstraints {
    cpuHours: number;
    gpuHours?: number;
    memoryGB: number;
    storageGB: number;
    networkBandwidth: number;
    cloudBudget?: number;
}
export interface SoftwareLicenseConstraints {
    availableLicenses: AvailableLicense[];
    licenseBudget: number;
    procurementTime: number;
    restrictions: string[];
}
export interface AvailableLicense {
    software: string;
    licenses: number;
    cost: number;
    renewalDate?: Date;
    restrictions: string[];
}
export interface DataAccessConstraints {
    dataAvailability: DataAvailability[];
    privacyConstraints: PrivacyConstraint[];
    dataGovernance: DataGovernanceConstraint[];
    dataQuality: DataQualityConstraint[];
}
export interface DataAvailability {
    dataSource: string;
    availability: 'full' | 'partial' | 'restricted' | 'unavailable';
    accessTime: number;
    cost: number;
    conditions: string[];
}
export interface PrivacyConstraint {
    constraint: string;
    applicableData: string[];
    compliance: string[];
    mitigations: string[];
}
export interface DataGovernanceConstraint {
    policy: string;
    requirements: string[];
    approvals: string[];
    timeline: number;
}
export interface DataQualityConstraint {
    qualityMetric: string;
    currentLevel: number;
    requiredLevel: number;
    improvementCost: number;
    improvementTime: number;
}
export interface SecurityConstraints {
    securityRequirements: SecurityRequirement[];
    complianceFrameworks: ComplianceFramework[];
    securityBudget: number;
    securityTimeline: number;
}
export interface SecurityRequirement {
    requirement: string;
    criticality: 'critical' | 'important' | 'desirable';
    currentCompliance: number;
    targetCompliance: number;
    implementation: string[];
}
export interface ComplianceFramework {
    framework: string;
    applicability: string[];
    requirements: string[];
    auditFrequency: string;
    penalties: string[];
}
export interface ExternalResourceConstraintsConfig {
    vendorConstraints: VendorConstraint[];
    partnerConstraints: PartnerConstraint[];
    regulatoryConstraints: RegulatoryConstraint[];
    marketConstraints: MarketConstraint[];
}
export interface VendorConstraint {
    vendor: string;
    services: string[];
    availability: string;
    cost: number;
    contractTerms: string[];
}
export interface PartnerConstraint {
    partner: string;
    capabilities: string[];
    availability: number;
    cost: number;
    dependencies: string[];
}
export interface RegulatoryConstraint {
    regulation: string;
    applicability: string[];
    compliance: string[];
    penalties: string[];
    timeline: number;
}
export interface MarketConstraint {
    constraint: string;
    impact: string[];
    timeline: string;
    mitigation: string[];
}
export interface TechnicalConstraintsConfig {
    platformConstraints: PlatformConstraint[];
    integrationConstraints: IntegrationConstraint[];
    performanceConstraints: PerformanceConstraint[];
    scalabilityConstraints: ScalabilityConstraint[];
}
export interface PlatformConstraint {
    platform: string;
    supportedFeatures: string[];
    limitations: string[];
    migrationCost?: number;
    migrationTime?: number;
}
export interface IntegrationConstraint {
    system: string;
    integrationPoints: string[];
    complexity: 'simple' | 'moderate' | 'complex';
    timeline: number;
    dependencies: string[];
}
export interface PerformanceConstraint {
    metric: string;
    requirement: number;
    currentPerformance?: number;
    improvement: string[];
    cost: number;
}
export interface ScalabilityConstraint {
    dimension: string;
    currentCapacity: number;
    requiredCapacity: number;
    scalingStrategy: string[];
    cost: number;
}
export interface OrganizationalConstraintsConfig {
    culturalConstraints: CulturalConstraint[];
    processConstraints: ProcessConstraint[];
    governanceConstraints: GovernanceConstraint[];
    changeManagementConstraints: ChangeManagementConstraint[];
}
export interface CulturalConstraint {
    aspect: string;
    currentState: string;
    desiredState: string;
    changeStrategy: string[];
    timeline: number;
}
export interface ProcessConstraint {
    process: string;
    currentMaturity: number;
    requiredMaturity: number;
    improvementPlan: string[];
    effort: number;
}
export interface