Вывод типа члена класса на основе другого члена

У меня есть класс TypeScript Foo с fieldOne: number | string и fieldTwo, который будет типа Bar[], когда fieldOne — это number, и Baz[], когда fieldOne — это string. Оба поля предоставляются как параметры конструктора.

Большая часть функциональности класса основана на объединении Bar и Baz, но в одном месте мне нужно сузить тип до Bar или Baz. Есть ли способ использовать компилятор, чтобы обеспечить создание экземпляра Foo только с помощью number и Bar[] или string и Baz[]. Затем в классе я могу сузить тип fieldTwo до Bar[] или Baz[], когда мне нужно?

Я могу добиться эффекта с помощью наследования, как показано здесь.

interface Bar {
  foo: string;
  bar: number;
}

interface Baz {
  foo: string;
  baz: number;
}

abstract class Foo<T extends number | string, U extends Bar[] | Baz[]> {
    private fieldOne: T;
    protected fieldTwo: U;

    constructor(paramOne: T, paramTwo: U) {
        this.fieldOne = paramOne;
        this.fieldTwo = paramTwo;
    }
    
    generalFunction() {
        console.info(this.fieldTwo.map(x => x.foo).join());
        this.specificFunction();
    }
    
    protected abstract specificFunction(): void;
}

class FooBar extends Foo<number, Bar[]> {
    specificFunction() {
        console.info(this.fieldTwo.map(x => x.bar).join());
    }
}

class FooBaz extends Foo<string, Baz[]> {
    specificFunction() {
        console.info(this.fieldTwo.map(x => x.baz).join());
    }
}

но я это немного затянуто.

Я надеялся получить что-то более лаконичное с условными типами, как здесь

type FooContents<T extends number | string> = T extends number ? Bar : Baz;

class Foo<T extends number | string> {
  private fieldOne: T;
  private fieldTwo: FooContents<T>;

  constructor(param1: T, param2: FooContents<T>) {
    this.fieldOne = param1;
    this.fieldTwo = param2;
  }

  generalFunction() {
    console.info(this.fieldTwo.foo);
  }

  specificFunction() {
    // somehow narrow the type, maybe based on this.fieldOne?
    // if fieldOne is number do something with Bar[];
    // if fieldOne is string do something with Baz[];
  }
}

но я не могу заставить его работать так, как мне нужно.

Третий способ, здесь, объединяет два поля в один объект.

type FooParams = {one: number, two: Bar[]} | {one: string, two: Baz[]};
class Foo {
    params: FooParams;

    constructor(params: FooParams) {
      this.params = params;
    }
    
    generalFunction() {
        console.info(this.params.two.map(x => x.foo).join());
    }

    specificFunction() {
      if (isNumberyBary(this.params)) this.processBars(this.params.two);
      if (isStringyBazy(this.params)) this.processBazs(this.params.two);
    }

    processBars(bars: Bar[]) {
        console.info(bars.map(x => x.bar).join());
    }

    processBazs(bazs: Baz[]) {
        console.info(bazs.map(x => x.baz).join());
    }
}

function isNumberyBary(x: FooParams): x is {one: number, two: Bar[]} {
  return typeof x === 'number';
}

function isStringyBazy(x: FooParams): x is {one: string, two: Baz[]} {
  return typeof x === 'number';
}

но опять же, это более затянуто, чем я надеялся.