CPOE Medication Errors Reduction: AI-Powered Order Entry Systems Cut Errors by 55%

Computerized Physician Order Entry (CPOE) systems have evolved from basic electronic prescribing tools to sophisticated AI-powered platforms that prevent medication errors before they occur. The integration of artificial intelligence with CPOE represents a critical advancement in patient safety, with recent studies showing 55% reductions in medication errors and $2.8 billion in annual cost savings.

This transformation is not just about digitizing prescriptions—it’s about creating intelligent clinical workflows that anticipate problems, suggest alternatives, and guide physicians toward optimal treatment decisions.

The Medication Error Crisis

Alarming Statistics:

• 237 million medication errors annually in the US
• 7,000-9,000 deaths from medication errors yearly
• $21 billion in additional healthcare costs
• 1 in 5 hospitalized patients experience adverse drug events

Traditional CPOE Limitations:

• Alert fatigue: 96% of alerts ignored by clinicians
• Workflow disruption: Increased documentation time by 20-30%
• Limited intelligence: Basic drug interaction checking only
• Poor usability: Complex interfaces leading to workarounds

AI-Powered CPOE: The Next Generation

Intelligent Order Entry Architecture

AI-Driven Medication Ordering:

// AI-Powered CPOE System Architecture
interface AIPoweredCPOE {
  analyzePatientContext(patientId: string): Promise<PatientMedicationContext>;
  generateMedicationRecommendations(
    condition: string,
    patientData: PatientRecord
  ): Promise<MedicationRecommendation[]>;
  validateOrder(
    order: MedicationOrder,
    context: PatientMedicationContext
  ): Promise<OrderValidation>;
  optimizeDosing(
    order: MedicationOrder,
    patientData: PatientRecord
  ): Promise<OptimizedOrder>;
  monitorTherapeuticOutcomes(orderId: string): Promise<TherapeuticMonitoring>;
}

class IntelligentMedicationOrdering implements AIPoweredCPOE {
  private aiEngine: AIMedicationEngine;
  private knowledgeBase: MedicationKnowledgeBase;
  private patientDataService: PatientDataService;
  private therapeuticMonitoring: TherapeuticMonitoringService;

  constructor() {
    this.aiEngine = new AIMedicationEngine();
    this.knowledgeBase = new MedicationKnowledgeBase();
    this.patientDataService = new PatientDataService();
    this.therapeuticMonitoring = new TherapeuticMonitoringService();
  }

  async analyzePatientContext(
    patientId: string
  ): Promise<PatientMedicationContext> {
    // Gather comprehensive patient medication context
    const patientRecord = await this.patientDataService.getPatientRecord(
      patientId
    );
    const activeMedications =
      await this.patientDataService.getActiveMedications(patientId);
    const medicationHistory =
      await this.patientDataService.getMedicationHistory(patientId);
    const allergies = await this.patientDataService.getAllergies(patientId);
    const labResults = await this.patientDataService.getRecentLabs(patientId);

    // Analyze medication patterns and risks
    const medicationPatterns = await this.analyzeMedicationPatterns(
      activeMedications,
      medicationHistory
    );
    const riskFactors = await this.assessRiskFactors(
      patientRecord,
      activeMedications,
      labResults
    );

    return {
      patientId,
      demographics: patientRecord.demographics,
      activeMedications,
      medicationHistory,
      allergies,
      labResults,
      medicationPatterns,
      riskFactors,
      contraindications: await this.identifyContraindications(
        activeMedications,
        patientRecord
      ),
    };
  }

  async generateMedicationRecommendations(
    condition: string,
    patientData: PatientRecord
  ): Promise<MedicationRecommendation[]> {
    // Get evidence-based medication options
    const evidenceBasedOptions =
      await this.knowledgeBase.getEvidenceBasedMedications(condition);

    // Filter by patient characteristics
    const patientSpecificOptions = await this.filterByPatientCharacteristics(
      evidenceBasedOptions,
      patientData
    );

    // Score and rank options using AI
    const scoredOptions = await this.aiEngine.scoreMedicationOptions(
      patientSpecificOptions,
      patientData
    );

    // Generate personalized recommendations
    return scoredOptions.map((option) => ({
      medication: option.medication,
      score: option.score,
      rationale: option.rationale,
      alternatives: option.alternatives,
      monitoringPlan: this.generateMonitoringPlan(
        option.medication,
        patientData
      ),
    }));
  }

  async validateOrder(
    order: MedicationOrder,
    context: PatientMedicationContext
  ): Promise<OrderValidation> {
    const validation: OrderValidation = {
      isValid: true,
      warnings: [],
      errors: [],
      suggestions: [],
      riskScore: 0,
    };

    // Drug interaction checking
    const interactions = await this.checkDrugInteractions(
      order,
      context.activeMedications
    );
    validation.warnings.push(...interactions.warnings);
    validation.errors.push(...interactions.errors);

    // Allergy checking
    const allergies = await this.checkAllergies(order, context.allergies);
    if (allergies.length > 0) {
      validation.errors.push(
        ...allergies.map((a) => `Allergic reaction risk: ${a.reaction}`)
      );
    }

    // Dose validation
    const doseValidation = await this.validateDosage(order, context);
    validation.warnings.push(...doseValidation.warnings);
    validation.errors.push(...doseValidation.errors);

    // Duplicate therapy checking
    const duplicates = await this.checkDuplicateTherapy(
      order,
      context.activeMedications
    );
    if (duplicates.length > 0) {
      validation.warnings.push(
        ...duplicates.map((d) => `Duplicate therapy: ${d.duplicateWith}`)
      );
    }

    // Renal/hepatic dose adjustment
    const organAdjustments = await this.checkOrganFunctionAdjustments(
      order,
      context.labResults
    );
    validation.suggestions.push(...organAdjustments);

    // Calculate overall risk score
    validation.riskScore = this.calculateRiskScore(
      validation.errors,
      validation.warnings
    );

    return validation;
  }

  async optimizeDosing(
    order: MedicationOrder,
    patientData: PatientRecord
  ): Promise<OptimizedOrder> {
    // Get patient-specific pharmacokinetic data
    const pkData = await this.calculatePharmacokinetics(
      order.medication,
      patientData
    );

    // Optimize dosing based on patient characteristics
    const optimizedDose = await this.aiEngine.optimizeDosage(
      order,
      pkData,
      patientData
    );

    // Generate dosing schedule
    const schedule = this.generateDosingSchedule(
      optimizedDose,
      order.medication
    );

    return {
      originalOrder: order,
      optimizedDose,
      schedule,
      rationale: await this.generateDosingRationale(optimizedDose, pkData),
      monitoringParameters: this.defineMonitoringParameters(
        order.medication,
        optimizedDose
      ),
    };
  }

  async monitorTherapeuticOutcomes(
    orderId: string
  ): Promise<TherapeuticMonitoring> {
    // Track medication effectiveness and side effects
    const outcomes = await this.therapeuticMonitoring.trackOutcomes(orderId);

    // Analyze therapeutic response
    const responseAnalysis = await this.analyzeTherapeuticResponse(outcomes);

    // Generate adjustment recommendations
    const adjustments = await this.generateAdjustmentRecommendations(
      responseAnalysis
    );

    return {
      orderId,
      outcomes,
      responseAnalysis,
      adjustments,
      nextMonitoringDate: this.calculateNextMonitoringDate(
        outcomes,
        responseAnalysis
      ),
    };
  }

  private async checkDrugInteractions(
    order: MedicationOrder,
    activeMeds: Medication[]
  ): Promise<InteractionCheck> {
    const interactions: InteractionCheck = { warnings: [], errors: [] };

    for (const activeMed of activeMeds) {
      const interaction = await this.knowledgeBase.checkInteraction(
        order.medication,
        activeMed
      );

      if (interaction) {
        if (interaction.severity === "severe") {
          interactions.errors.push(
            `${order.medication.name} + ${activeMed.name}: ${interaction.description}`
          );
        } else if (interaction.severity === "moderate") {
          interactions.warnings.push(
            `${order.medication.name} + ${activeMed.name}: ${interaction.description}`
          );
        }
      }
    }

    return interactions;
  }

  private async checkAllergies(
    order: MedicationOrder,
    allergies: Allergy[]
  ): Promise<AllergyAlert[]> {
    const alerts: AllergyAlert[] = [];

    for (const allergy of allergies) {
      const crossReactivity = await this.knowledgeBase.checkCrossReactivity(
        order.medication,
        allergy.substance
      );

      if (crossReactivity.risk > 0.7) {
        // High risk threshold
        alerts.push({
          substance: allergy.substance,
          reaction: allergy.reaction,
          crossReactivity: crossReactivity.risk,
          recommendation: crossReactivity.alternative
            ? `Consider ${crossReactivity.alternative}`
            : "Avoid this medication",
        });
      }
    }

    return alerts;
  }

  private async validateDosage(
    order: MedicationOrder,
    context: PatientMedicationContext
  ): Promise<DoseValidation> {
    const validation: DoseValidation = { warnings: [], errors: [] };

    // Check maximum daily dose
    if (order.dose.amount > order.medication.maxDailyDose) {
      validation.errors.push(
        `Dose exceeds maximum daily limit of ${order.medication.maxDailyDose}${order.medication.units}`
      );
    }

    // Check age-appropriate dosing
    const age = this.calculateAge(context.demographics.dateOfBirth);
    if (order.medication.pediatricOnly && age > 18) {
      validation.errors.push("This medication is for pediatric use only");
    }

    // Check weight-based dosing
    if (order.medication.weightBased && context.demographics.weight) {
      const weightBasedDose = this.calculateWeightBasedDose(
        order.medication,
        context.demographics.weight
      );
      if (
        Math.abs(order.dose.amount - weightBasedDose) / weightBasedDose >
        0.2
      ) {
        // 20% deviation
        validation.warnings.push(
          `Dose deviates from weight-based recommendation of ${weightBasedDose}${order.medication.units}`
        );
      }
    }

    return validation;
  }

  private calculateRiskScore(errors: string[], warnings: string[]): number {
    // Risk scoring algorithm
    let score = 0;

    // Errors are critical (high risk)
    score += errors.length * 100;

    // Warnings add moderate risk
    score += warnings.length * 20;

    // Cap at 100
    return Math.min(100, score);
  }

  private calculateAge(dateOfBirth: string): number {
    const birth = new Date(dateOfBirth);
    const today = new Date();
    return today.getFullYear() - birth.getFullYear();
  }

  private calculateWeightBasedDose(
    medication: Medication,
    weight: number
  ): number {
    // Simplified weight-based dosing calculation
    // In practice, this would be more complex based on medication-specific formulas
    return weight * medication.dosePerKg;
  }

  private async analyzeMedicationPatterns(
    activeMeds: Medication[],
    history: MedicationHistory[]
  ): Promise<MedicationPatterns> {
    // Analyze medication usage patterns
    const patterns: MedicationPatterns = {
      polypharmacy: activeMeds.length > 5,
      highRiskMedications: activeMeds.filter((med) => med.highRisk).length,
      drugClasses: this.groupByDrugClass(activeMeds),
      adherencePatterns: await this.analyzeAdherencePatterns(history),
      costBurden: this.calculateCostBurden(activeMeds),
    };

    return patterns;
  }

  private groupByDrugClass(medications: Medication[]): {
    [key: string]: number;
  } {
    const classes: { [key: string]: number } = {};

    medications.forEach((med) => {
      classes[med.drugClass] = (classes[med.drugClass] || 0) + 1;
    });

    return classes;
  }

  private async analyzeAdherencePatterns(
    history: MedicationHistory[]
  ): Promise<AdherencePatterns> {
    // Analyze medication adherence patterns
    const patterns: AdherencePatterns = {
      averageAdherence: this.calculateAverageAdherence(history),
      refillPatterns: this.analyzeRefillPatterns(history),
      discontinuationRisk: await this.assessDiscontinuationRisk(history),
    };

    return patterns;
  }

  private calculateAverageAdherence(history: MedicationHistory[]): number {
    if (history.length === 0) return 1.0;

    const totalDays = history.length * 30; // Assuming monthly history
    const adherentDays = history.filter((h) => h.adherent).length * 30;

    return adherentDays / totalDays;
  }

  private analyzeRefillPatterns(history: MedicationHistory[]): RefillPattern[] {
    // Analyze refill timing patterns
    return history.map((h) => ({
      medication: h.medication,
      refillInterval: h.refillInterval,
      timeliness:
        h.daysEarly > 0 ? "early" : h.daysLate > 0 ? "late" : "on_time",
    }));
  }

  private async assessDiscontinuationRisk(
    history: MedicationHistory[]
  ): Promise<number> {
    // Assess risk of medication discontinuation
    // This would use ML models trained on historical data
    return 0.3; // Placeholder
  }

  private calculateCostBurden(medications: Medication[]): number {
    // Calculate monthly medication cost burden
    return medications.reduce((total, med) => total + med.monthlyCost, 0);
  }

  private async assessRiskFactors(
    record: PatientRecord,
    medications: Medication[],
    labs: LabResult[]
  ): Promise<RiskFactors> {
    const factors: RiskFactors = {
      renalImpairment: await this.assessRenalFunction(labs),
      hepaticImpairment: await this.assessHepaticFunction(labs),
      cardiovascularRisk: await this.assessCardiovascularRisk(
        record,
        medications
      ),
      fallRisk: await this.assessFallRisk(record, medications),
      cognitiveImpairment: await this.assessCognitiveRisk(record, medications),
    };

    return factors;
  }

  private async assessRenalFunction(labs: LabResult[]): Promise<boolean> {
    const creatinine = labs.find((l) => l.testName === "creatinine");
    if (!creatinine) return false;

    // Calculate eGFR using CKD-EPI formula (simplified)
    const egfr = 141 * Math.min(creatinine.value / 0.9, 1) ** -0.411;
    return egfr < 60; // CKD stage 3 or worse
  }

  private async assessHepaticFunction(labs: LabResult[]): Promise<boolean> {
    const alt = labs.find((l) => l.testName === "ALT");
    const ast = labs.find((l) => l.testName === "AST");

    if (!alt || !ast) return false;

    // Check for elevated liver enzymes
    return alt.value > 40 || ast.value > 40;
  }

  private async assessCardiovascularRisk(
    record: PatientRecord,
    medications: Medication[]
  ): Promise<number> {
    // Calculate cardiovascular risk score
    let risk = 0;

    // Age factor
    const age = this.calculateAge(record.demographics.dateOfBirth);
    if (age > 65) risk += 2;

    // Medication factors
    if (medications.some((m) => m.drugClass === "antihypertensives")) risk += 1;
    if (medications.some((m) => m.drugClass === "statins")) risk += 1;

    return risk;
  }

  private async assessFallRisk(
    record: PatientRecord,
    medications: Medication[]
  ): Promise<number> {
    // Assess fall risk based on medications and patient factors
    let risk = 0;

    // High-risk medications
    const highRiskMeds = medications.filter(
      (m) => m.fallRisk === "high"
    ).length;
    risk += highRiskMeds * 2;

    // Age factor
    const age = this.calculateAge(record.demographics.dateOfBirth);
    if (age > 75) risk += 1;

    return risk;
  }

  private async assessCognitiveRisk(
    record: PatientRecord,
    medications: Medication[]
  ): Promise<number> {
    // Assess risk of cognitive impairment from medications
    let risk = 0;

    // Anticholinergics and other cognition-impairing drugs
    const cognitiveRiskMeds = medications.filter(
      (m) => m.cognitiveRisk === "high"
    ).length;
    risk += cognitiveRiskMeds;

    return risk;
  }

  private async identifyContraindications(
    medications: Medication[],
    record: PatientRecord
  ): Promise<Contraindication[]> {
    const contraindications: Contraindication[] = [];

    for (const medication of medications) {
      const contraindication = await this.knowledgeBase.checkContraindications(
        medication,
        record
      );

      if (contraindication) {
        contraindications.push({
          medication: medication.name,
          condition: contraindication.condition,
          severity: contraindication.severity,
          alternative: contraindication.alternative,
        });
      }
    }

    return contraindications;
  }

  private generateMonitoringPlan(
    medication: Medication,
    patientData: PatientRecord
  ): MonitoringPlan {
    // Generate medication-specific monitoring plan
    return {
      parameters: medication.monitoringParameters || [],
      frequency: medication.monitoringFrequency || "monthly",
      responsibleParty: "primary_care_provider",
      alerts: medication.criticalAlerts || [],
    };
  }

  private async filterByPatientCharacteristics(
    options: MedicationOption[],
    patientData: PatientRecord
  ): Promise<MedicationOption[]> {
    return options.filter((option) => {
      // Check contraindications
      if (option.contraindications) {
        for (const contraindication of option.contraindications) {
          if (this.patientHasContraindication(patientData, contraindication)) {
            return false;
          }
        }
      }

      // Check allergies
      if (patientData.allergies?.includes(option.medication.name)) {
        return false;
      }

      // Check age restrictions
      const age = this.calculateAge(patientData.demographics.dateOfBirth);
      if (option.ageRestrictions) {
        if (
          age < option.ageRestrictions.min ||
          age > option.ageRestrictions.max
        ) {
          return false;
        }
      }

      return true;
    });
  }

  private patientHasContraindication(
    patientData: PatientRecord,
    contraindication: string
  ): boolean {
    // Check if patient has the contraindicated condition
    return (
      patientData.medicalHistory?.conditions?.includes(contraindication) ||
      false
    );
  }

  private generateDosingSchedule(
    dose: OptimizedDose,
    medication: Medication
  ): DosingSchedule {
    // Generate optimal dosing schedule
    return {
      dose: dose.amount,
      unit: dose.unit,
      frequency: dose.frequency,
      timing: this.optimizeTiming(medication, dose),
      duration: dose.duration,
      tapering: dose.tapering,
    };
  }

  private optimizeTiming(
    medication: Medication,
    dose: OptimizedDose
  ): string[] {
    // Optimize medication timing based on pharmacokinetics
    if (medication.timing === "with_food") {
      return ["with_meal"];
    } else if (medication.timing === "empty_stomach") {
      return ["1_hour_before_meal", "2_hours_after_meal"];
    }

    return ["anytime"];
  }

  private defineMonitoringParameters(
    medication: Medication,
    dose: OptimizedDose
  ): MonitoringParameter[] {
    // Define monitoring parameters for the medication
    const parameters: MonitoringParameter[] = [];

    if (medication.monitoringParameters) {
      parameters.push(
        ...medication.monitoringParameters.map((param) => ({
          parameter: param,
          frequency: medication.monitoringFrequency || "monthly",
          threshold: this.getMonitoringThreshold(param, medication),
          action: this.getMonitoringAction(param, medication),
        }))
      );
    }

    return parameters;
  }

  private getMonitoringThreshold(
    parameter: string,
    medication: Medication
  ): Threshold {
    // Get monitoring thresholds for specific parameters
    // This would be medication-specific
    return {
      min: 0,
      max: 100,
      criticalMin: 0,
      criticalMax: 100,
    };
  }

  private getMonitoringAction(
    parameter: string,
    medication: Medication
  ): string {
    // Define actions for monitoring alerts
    return "consult_pharmacist";
  }

  private async analyzeTherapeuticResponse(
    outcomes: TherapeuticOutcome[]
  ): Promise<ResponseAnalysis> {
    // Analyze therapeutic response patterns
    const analysis: ResponseAnalysis = {
      effectiveness: this.calculateEffectiveness(outcomes),
      sideEffects: this.analyzeSideEffects(outcomes),
      adherence: this.calculateAdherence(outcomes),
      overallResponse: "improving", // Placeholder
    };

    return analysis;
  }

  private calculateEffectiveness(outcomes: TherapeuticOutcome[]): number {
    // Calculate therapeutic effectiveness score
    const positiveOutcomes = outcomes.filter((o) => o.effective).length;
    return positiveOutcomes / outcomes.length;
  }

  private analyzeSideEffects(
    outcomes: TherapeuticOutcome[]
  ): SideEffectAnalysis {
    // Analyze side effect patterns
    const sideEffects = outcomes.flatMap((o) => o.sideEffects || []);

    return {
      commonSideEffects: this.findCommonSideEffects(sideEffects),
      severityDistribution: this.calculateSeverityDistribution(sideEffects),
      managementStrategies: this.suggestManagementStrategies(sideEffects),
    };
  }

  private findCommonSideEffects(sideEffects: SideEffect[]): SideEffect[] {
    // Find most common side effects
    const effectCounts = new Map<string, number>();

    sideEffects.forEach((effect) => {
      effectCounts.set(effect.name, (effectCounts.get(effect.name) || 0) + 1);
    });

    return Array.from(effectCounts.entries())
      .sort((a, b) => b[1] - a[1])
      .slice(0, 5)
      .map(([name, count]) => ({ name, severity: "mild", frequency: count }));
  }

  private calculateSeverityDistribution(
    sideEffects: SideEffect[]
  ): SeverityDistribution {
    const distribution = {
      mild: sideEffects.filter((se) => se.severity === "mild").length,
      moderate: sideEffects.filter((se) => se.severity === "moderate").length,
      severe: sideEffects.filter((se) => se.severity === "severe").length,
    };

    return distribution;
  }

  private suggestManagementStrategies(sideEffects: SideEffect[]): string[] {
    // Suggest management strategies for side effects
    return ["dose_adjustment", "symptom_management", "alternative_medication"];
  }

  private calculateAdherence(outcomes: TherapeuticOutcome[]): number {
    // Calculate medication adherence rate
    const adherentOutcomes = outcomes.filter((o) => o.adherent).length;
    return adherentOutcomes / outcomes.length;
  }

  private async generateAdjustmentRecommendations(
    analysis: ResponseAnalysis
  ): Promise<AdjustmentRecommendation[]> {
    const recommendations: AdjustmentRecommendation[] = [];

    // Effectiveness-based recommendations
    if (analysis.effectiveness < 0.7) {
      recommendations.push({
        type: "dose_increase",
        rationale: "Suboptimal therapeutic response",
        priority: "high",
      });
    }

    // Side effect-based recommendations
    if (analysis.sideEffects.severityDistribution.severe > 0) {
      recommendations.push({
        type: "dose_decrease",
        rationale: "Severe side effects reported",
        priority: "high",
      });
    }

    // Adherence-based recommendations
    if (analysis.adherence < 0.8) {
      recommendations.push({
        type: "adherence_support",
        rationale: "Low adherence detected",
        priority: "medium",
      });
    }

    return recommendations;
  }

  private calculateNextMonitoringDate(
    outcomes: TherapeuticOutcome[],
    analysis: ResponseAnalysis
  ): Date {
    // Calculate next monitoring date based on response analysis
    const baseDate = new Date();

    if (analysis.overallResponse === "improving") {
      baseDate.setMonth(baseDate.getMonth() + 3); // 3 months
    } else if (analysis.overallResponse === "stable") {
      baseDate.setMonth(baseDate.getMonth() + 1); // 1 month
    } else {
      baseDate.setDate(baseDate.getDate() + 7); // 1 week
    }

    return baseDate;
  }
}

interface PatientMedicationContext {
  patientId: string;
  demographics: Demographics;
  activeMedications: Medication[];
  medicationHistory: MedicationHistory[];
  allergies: Allergy[];
  labResults: LabResult[];
  medicationPatterns: MedicationPatterns;
  riskFactors: RiskFactors;
  contraindications: Contraindication[];
}

interface MedicationRecommendation {
  medication: Medication;
  score: number;
  rationale: string;
  alternatives: Medication[];
  monitoringPlan: MonitoringPlan;
}

interface OrderValidation {
  isValid: boolean;
  warnings: string[];
  errors: string[];
  suggestions: string[];
  riskScore: number;
}

interface OptimizedOrder {
  originalOrder: MedicationOrder;
  optimizedDose: OptimizedDose;
  schedule: DosingSchedule;
  rationale: string;
  monitoringParameters: MonitoringParameter[];
}

interface TherapeuticMonitoring {
  orderId: string;
  outcomes: TherapeuticOutcome[];
  responseAnalysis: ResponseAnalysis;
  adjustments: AdjustmentRecommendation[];
  nextMonitoringDate: Date;
}

interface InteractionCheck {
  warnings: string[];
  errors: string[];
}

interface AllergyAlert {
  substance: string;
  reaction: string;
  crossReactivity: number;
  recommendation: string;
}

interface DoseValidation {
  warnings: string[];
  errors: string[];
}

interface MedicationPatterns {
  polypharmacy: boolean;
  highRiskMedications: number;
  drugClasses: { [key: string]: number };
  adherencePatterns: AdherencePatterns;
  costBurden: number;
}

interface AdherencePatterns {
  averageAdherence: number;
  refillPatterns: RefillPattern[];
  discontinuationRisk: number;
}

interface RefillPattern {
  medication: string;
  refillInterval: number;
  timeliness: "early" | "on_time" | "late";
}

interface RiskFactors {
  renalImpairment: boolean;
  hepaticImpairment: boolean;
  cardiovascularRisk: number;
  fallRisk: number;
  cognitiveImpairment: number;
}

interface Contraindication {
  medication: string;
  condition: string;
  severity: string;
  alternative?: string;
}

interface;