Ввод объекта с одинаковыми ключами, но разными типами их значений

Это работает, но сложно точно сказать, что вы ищете, не видя вашего getData метода.

interface SourceEn {
    action: string[],
    device: string[],
}

interface SourcePl {
    action: string[],
    device: NounForms[],
}

interface NounForms {
    gender: 'm' | 'f' | 'n' | 'pl';
    singular: string;
    plural: string;
}

type Source = SourceEn | SourcePl;

class Collection<T> {
  public constructor(private store: T) {} // Add the array back in here if that's your intention, but then use the commented out return value below.
}

type ArrayItem<A extends unknown[]> = A extends (infer E)[] ? E : never;

enum Language {
  EN = 'en',
  PL = 'pl',
}

class BaseConsumer<T extends Source> {

    public readonly action: Collection<T['action']>;
    public readonly device: Collection<T['device']>;

    public constructor(language: Language) {
        const data: T = this.getData(language)
        // this.action = new Collection<typeof data.action>([data.action]); Either this one if you want an array of arrays.
        this.action = new Collection<typeof data.action>(data.action); // Or this one, but then I removed the array from your Collection class.
        this.device = new Collection<typeof data.device>(data.device);
    }

    protected getData(language: Language): T { return null! as T }
}

Если вам нужен массив массивов, используйте закомментированное возвращаемое значение, возможно, с методом, который проверяет, является ли это массивом нужной глубины, чтобы всегда возвращать его в нужной форме, в противном случае удалите массив из Collection класс.

Детская площадка

Минимальные изменения для устранения ошибок следующие:

type ArrayItem<A extends unknown[]> = A[number];

class BaseConsumer<T extends Source> {
    public readonly action: Collection<ArrayItem<T['action']>>;
    public readonly device: Collection<ArrayItem<T['device']>>;

    public constructor(language: Language) {
        const data = this.getData(language);
        this.action = new Collection<ArrayItem<T['action']>>(data.action);
        this.device = new Collection<ArrayItem<T['device']>>(data.device);
    }

    protected getData(language: Language): T { return null! }
}

Я изменил ArrayItem ваш условный тип на более простой индексированный тип доступа . Массив типа Array<X> имеет числовую сигнатуру индекса типа {[k: number]: X}, поскольку TypeScript моделирует массивы как имеющие элементы с числовыми ключами. Итак, если у вас есть string[] и вы вносите в него индекс с помощью числового ключа, вы получите string. Ваш условный тип концептуально один и тот же, но компилятору гораздо сложнее рассуждать об универсальных условных типах, чем об универсальных типах индексированного доступа.

Я также вручную указал аргумент универсального типа для Collection, чтобы он был соответствующим универсальным типом. Если вы этого не сделаете, компилятор попытается вывести этот тип, и в конечном итоге он расширится data от T до ограничения Source, а объединение больше не будет соответствовать типу this.action и this.device. Расширение универсальных значений TypeScript до их ограничений — распространенная ошибка, и один из способов избежать этого — вручную указывать аргументы универсального типа для функций.

Это все хорошо, но вы не получите от BaseConsumer общего поведения, которое вам нужно. Поскольку аргумент конструктора не является общим Language, вы получаете бесполезный BaseConsumer<Source>:

const pl = new BaseConsumer(Language.PL)
//const pl: BaseConsumer<Source>
pl.device
// ^? (property) BaseConsumer<Source>.device: Collection<string | NounForms>

Это не то, чего вы хотите. Тип pl.device должен быть Collection<NounForms>, верно? Поэтому нам нужен другой подход.

Чтобы это работало, мы должны сделать BaseConsumer<L>общим в типе L аргумента language constructor, а затем использовать тип сопоставления для соединения этих языковых имен с соответствующими типами данных action и device без каких-либо массивов для получения в пути. То есть мы могли бы использовать отображение типа

interface LanguageSourceMap {
    en: {
        action: string,
        device: string,
    },
    pl: {
        action: string,
        device: NounForms,
    }
}

а затем, например, LanguageSourceMap[L]['action'] — это тип данных action для языка L (с использованием индексированных типов доступа для детализации ключа и подраздела LanguageSourceMap).

Как только мы это получим, мы можем написать BaseConsumer как:

class BaseConsumer<L extends Language> {
    public readonly action: Collection<LanguageSourceMap[L]['action']>;
    public readonly device: Collection<LanguageSourceMap[L]['device']>;

    public constructor(language: L) {
        const data = this.getData(language);
        this.action = new Collection(data.action);
        this.device = new Collection(data.device);
    }

    protected getData(language: Language):
        { [K in keyof LanguageSourceMap[L]]:
            LanguageSourceMap[L][K][] } { return null! }
}

что работает хорошо, потому что теперь getData() возвращает сопоставленный тип поверх LanguageSourceMap[L], и индексация в него с помощью action или device дает именно тот индексированный тип доступа, который у нас есть для this.action и this.device. Компилятору гораздо легче делать выводы о LanguageSourceMap[L][K][], где L extends Language и K extends keyof LanguageSourceMap[K], чем о T extends Source. Компилятору проще анализировать отображаемые типы и индексированные типы доступа, чем объединения и условные типы. Основу этого подхода см. в microsoft/TypeScript#47109, где мы начинаем с базового типа сопоставления, такого как LanguageSourceMap, и выражаем вещи в терминах универсальных индексов в этот тип и в отображаемые типы поверх этого типа.

Давайте убедимся, что new BaseConsumer ведет себя так, как мы хотим:

const pl = new BaseConsumer(Language.PL)
// const pl: BaseConsumer<Language.PL>
pl.device
// ^? (property) BaseConsumer<Language.PL>.device: Collection<NounForms>

Выглядит неплохо.

Мы почти закончили. Единственное, мы не хотим выписывать LanguageSourceMap вручную, когда у вас уже есть типы SourceEn и SourcePl. Итак, давайте перепишем LanguageSourceMap так, чтобы он явно их использовал:

type ToBaseSource<T extends Record<keyof T, any[]>> =
    { [K in keyof T]: T[K][number] };

interface LanguageSourceMap {
    [Language.EN]: ToBaseSource<SourceEn>;
    [Language.PL]: ToBaseSource<SourcePl>;
}

Здесь ToBaseSource<T> принимает любые T, все свойства которых являются массивами (он использует рекурсивное ограничение T extends Record<keyof T, any[]>. Ограничения типа X extends Record<keyof X, Y> полезны для ограничения типа значения свойств, не заботясь о типе ключа), и для каждого свойства массива T[K] используется индексированный number доступ для получения типа элемента массива. Это то же самое, что и упрощенное ArrayItem, сопоставленное со свойствами t.

И вот мы закончили. LanguageSourceMap здесь эквивалентен руководству, написанному выше.

Обратите внимание, что все это было бы проще, если бы вы начали с LanguageSourceMap и вычислили SourceEn и SourePl с его помощью. Но это не так, и, очевидно, вы не можете контролировать эти типы. Так что это лучшее, что я могу предложить.

Детская площадка, ссылка на код