From Erlang-C to Digital Deflection: Building a Modern ROI Simulator

class EnhancedErlangCalculator {
    calculateWaitTime(params: ContactCenterParams): number {
      const { 
        hourlyVolume, 
        agents, 
        baseAHT, 
        deflectionRate, 
        aiEfficiency 
      } = params;
      
      // Apply digital deflection
      const effectiveVolume = hourlyVolume * (1 - deflectionRate / 100);
      
      // Apply AI efficiency to AHT
      const effectiveAHT = baseAHT * (1 - aiEfficiency / 100);
      
      // Calculate utilization
      const rho = (effectiveVolume * effectiveAHT) / (60 * agents);
      
      if (rho >= 0.99) return 3600; // System saturated
      
      // Enhanced wait time formula
      const waitTime = (Math.pow(rho, 2) / (1 - rho)) * 
                      (effectiveAHT * 60 / agents);
      
      return Math.min(waitTime, 3600);
    }
  }

interface DeflectionModel {
    calculateDeflectionRate(
      channelEffectiveness: number,
      contentQuality: number,
      userExperience: number
    ): number;
  }

  class AdvancedDeflectionModel implements DeflectionModel {
    calculateDeflectionRate(
      channelEffectiveness: number,
      contentQuality: number, 
      userExperience: number
    ): number {
      // Weighted combination of factors
      const weights = {
        channel: 0.4,
        content: 0.35,
        ux: 0.25
      };
      
      const baseRate = (
        channelEffectiveness * weights.channel +
        contentQuality * weights.content +
        userExperience * weights.ux
      );
      
      // Apply diminishing returns curve
      return this.applyDiminishingReturns(baseRate);
    }
    
    private applyDiminishingReturns(rate: number): number {
      // Sigmoid function for realistic deflection curves
      return 100 / (1 + Math.exp(-0.1 * (rate - 50)));
    }
  }

class AIEfficiencyCalculator {
    calculateAHTReduction(
      agentExperience: number,
      aiCapability: number,
      integrationQuality: number
    ): number {
      // Base efficiency from AI capability
      let efficiency = aiCapability * 0.3; // Max 30% base reduction
      
      // Agent experience multiplier
      const experienceMultiplier = 1 + (agentExperience - 50) / 100;
      efficiency *= experienceMultiplier;
      
      // Integration quality factor
      const integrationFactor = integrationQuality / 100;
      efficiency *= integrationFactor;
      
      // Apply realistic bounds
      return Math.max(0, Math.min(50, efficiency));
    }
    
    calculateAccuracyImprovement(
      knowledgeBaseQuality: number,
      aiTraining: number
    ): number {
      const baseAccuracy = 0.7; // 70% baseline
      const improvement = (knowledgeBaseQuality + aiTraining) / 200;
      
      return Math.min(0.95, baseAccuracy + improvement);
    }
  }