Объедините универсальные интерфейсы с двумя универсальными типами в один тип только с одним универсальным типом

В моем случае я работаю с использованиередьюсер из React, но мой вопрос касается чисто машинописного текста.

Возьмите следующее:

export interface State<T> {
  values: T;
  someOtherProp: boolean;
}

export interface ActionOne<T, K extends keyof T> {
  type: "UPDATE_VALUE_ONE";
  payload: { name: K; value: T[K] };
}


export interface ActionTwo<T, K extends keyof T> {
  type: "UPDATE_VALUE_TWO";
  payload: { name: K; value: T[K] };
}

Теперь два интерфейса действий объединены в один тип объединения:

type ActionTypes<T, K extends keyof T> = ActionOne<T, K> | ActionTwo<T, K>

На следующем шаге функция будет использовать ActionTypes в качестве типа своего параметра:

export const reducer = <T>(
  state: State<T>,
  action: ActionTypes<T> // This already breaks because the second generic type is missing
): State<T> =>
{ 
   switch (action.type) {
     case "UPDATE_VALUE_ONE":
      return {
        ...state,
        values: { ...state.values, [action.payload.name]: action.payload.value}
      };
     case "UPDATE_VALUE_ONE":
    // ...
  }
}

Как вы можете видеть в комментарии к коду, ActionTypes<T> уже ломается. В моем случае я не хочу, чтобы функция reducer беспокоилась о том, какой тип K у ActionTypes<T, K>.

Я знаю, что могу добавить keyof T к action: ActionTypes<T, keyof T>, но это нарушит проверку типов для этой строки:

values: { ...state.values, [action.payload.name]: action.payload.value}

потому что тип [action.payload.name] может отличаться от action.payload.value

На самом деле было бы даже лучше, если бы ActionType<T, K extends keyof T> имел только один общий тип (T).

Если бы ActionOne и ActionTwo возвращались функциями вместо того, чтобы передавать их напрямую как объект, это работало бы, объявляя встроенные функции:

type ActionTypes<T> =
 | (<T, K extends keyof T>() => ActionOne<T, K>)
 | (<T, K extends keyof T>() => ActionTwo<T, K>);`

Вопрос

Как информация второго универсального типа K интерфейса может быть «скрыта», когда она используется в другом интерфейсе/типе, который объявляет только один универсальный тип T? (Особенно, если K в любом случае зависит от T посредством K extends keyof T.)

Для универсальных функций это можно решить с помощью встроенного объявления, так как же это можно решить для интерфейсов?