export type SpeechToTextLanguage =
  | 'af'
  | 'sq'
  | 'ar'
// this continues

// 1. Define specific option types first for reusability
interface KokoroOptions {
  temperature: number;
  contextSize: number;
}

interface OtherOptions {
  language: string;
  beamSize: number;
}

// 2. Define the Configs with a strict 'type' discriminator
interface KokoroConfig {
  type: 'kokoro';
  modelPath: string;
  options: KokoroOptions;
}

interface OtherModelConfig {
  type: 'other';
  modelPath: string;
  options: OtherOptions;
}

type ModelConfig = KokoroConfig | OtherModelConfig;

class GenericModel {
  public async load(config: ModelConfig): Promise<void> {
    switch (config.type) {
      case 'kokoro':
        // TypeScript implies config is KokoroConfig here
        await this.loadKokoro(config.modelPath, config.options);
        break;
      
      case 'other':
        // TypeScript implies config is OtherModelConfig here
        await this.loadOther(config.modelPath, config.options);
        break;
    }
  }

  private async loadKokoro(path: string, options: KokoroOptions) {
    console.log(`Loading Kokoro with temp: ${options.temperature}`);
    // implementation...
  }

  private async loadOther(path: string, options: OtherOptions) {
    console.log(`Loading Other with lang: ${options.language}`);
    // implementation...
  }
}