Typescript - тип безопасный глубокий пропуск, или: как перечислить допустимые пути к объектам

Хорошо, это длинный и очень конкретный. Был бы очень признателен за любой вклад.

Я написал рекурсивный тип Omit, который принимает тип T и кортеж строк («путь») и индексирует в T, удаляя последний элемент на пути и возвращая этот тип.

Я уже смотрел Deep Omit With Typescript, но это касается рекурсивного пропуска одного и того же ключа вместо того, чтобы идти по пути.

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

Моя реализация:

// for going along the tuple that is the path
type Tail<T extends any[]> = ((...args: T) => void) extends ((head: unknown, ...rest: infer U) => void) ? U : never;

type DeepOmit<T, Path extends string[]> = T extends object ? {
    0: Omit<T, Path[0]>;
    1: { [K in keyof T]: K extends Path[0] ? DeepOmit<T[K], Tail<Path>> : T[K] }
}[Path['length'] extends 1 ? 0 : 1] : T;

Я хочу сделать так, чтобы Path был ограничен допустимым обходом T, например:

Path = [K1, K2, K3, ..., K_n] such that:
K1 extends keyof T, K2 extends keyof T[K1], ... Kn extends keyof[T][K1]...[K_(n-1)]

Первая попытка

Я написал тип, который принимает тип T и путь P и возвращает P, если он действителен, или never в противном случае:

type ExistingPathInObject<T, P extends any[]> = P extends [] ? P : {
    0: ExistingPathInObject<T[P[0]], Tail<P>> extends never ? never : P;
    1: never;
}[P[0] extends keyof T ? 0 : 1]

Однако в подписи DeepOmit я не могу применить Path extends ExistingPathInObject<T,Path>, поскольку это циклическая зависимость. Я упоминаю об этой попытке, потому что может быть способ обойти замкнутость и использовать этот тип для проверки Path как действительного обхода T.

Вторая попытка

Поскольку я не могу использовать Path для ограничения себя, я вместо этого попытался сгенерировать объединение всех существующих путей в типе, а затем потребовал Path для его расширения. Лучшее, что я мог придумать, это следующее:

type Paths<T> = {
    0: { [K in keyof T]: T[K] extends object ? [K, Paths<T[K]>[keyof Paths<T[K]>]] : [K] }
    1: []
}[T extends object ? 0 : 1];

// an example type to test on
type HasNested = { a: string; b: { c: number; d: string } };

type pathTest = Paths<HasNested>;
//{
//  a: ["a"];
//  b: ["b", ["d"] | ["c"]];
//}

type pathTestUnion = Paths<HasNested>[keyof Paths<HasNested>]
// ["a"] | ["b", ["d"] | ["c"]]

Это позволяет мне сопоставить путь, записанный в виде дерева: ['a'] extends pathTestUnion и ['b', ['d']] extends pathTestUnion оба истинны. Мне нужно добавить [keyof T], чтобы получить объединение, и я не могу поместить его в сам тип Paths, потому что он не распознается как действительный.

После всего этого у меня возникли трудности с переписыванием DeepOmit, чтобы использовать это ограничение. Вот что я пробовал:

type Types<T> = T[keyof T];

type TypeSafeDeepOmit<T, Path extends Types<Paths<T>>, K extends keyof T> =
    Path extends any[] ?
    T extends object ?
    { // T is object and Path is any[]
        0: Omit<T, K>;
        1: { [P in keyof T]: P extends Path[0] ? TypeSafeDeepOmit<T[P], Path[1], Path[1][0]> : T[P] }
    }[Path['length'] extends 1 ? 0 : 1] :
    T : // if T is not object
    never; // if Path is not any[]

type TSDO_Helper<T, P extends Types<Paths<T>>> = P extends any[] ? P[0] extends keyof T ? TypeSafeDeepOmit<T, P, P[0]> : never : never;

Это уродливо, и на самом деле он использует вспомогательный тип. Я также должен сообщить компилятору, что P extends any[] и P[0] extends keyof T, хотя это именно то, что Paths должно гарантировать. Я также получаю сообщение об ошибке при рекурсивном вызове TypeSafeDeepOmit с использованием Path[1] -

Type 'any[] & Path' is not assignable to type '[]'.
        Types of property 'length' are incompatible.
          Type 'number' is not assignable to type '0'

Я исправил это, установив Path extends Types<Paths<T>> | [], но я не уверен, что это правильный способ.

Вкратце

Итак, есть ли лучший способ обеспечить правильный путь? Можно ли также поддерживать объединение путей, чтобы исключить их все? Прямо сейчас результат, который я получаю, представляет собой объединение результатов различных пропусков.