Как в TypeScript получить ключи типа объекта, значения которого относятся к данному типу?

Это можно сделать с помощью условных типов и типы поиска, вот так:

type KeysMatching<T, V> = {[K in keyof T]-?: T[K] extends V ? K : never}[keyof T];

а затем вы извлекаете ключи, свойства которых совпадают string следующим образом:

const key: KeysMatching<Thing, string> = 'other'; // ERROR!
// '"other"' is not assignable to type '"id"'

В деталях:

KeysMatching<Thing, string> ➡

{[K in keyof Thing]-?: Thing[K] extends string ? K : never}[keyof Thing] ➡

{ 
  id: string extends string ? 'id' : never; 
  price: number extends string ? 'number' : never;
  other: { stuff: boolean } extends string ? 'other' : never;
}['id'|'price'|'other'] ➡

{ id: 'id', price: never, other: never }['id' | 'price' | 'other'] ➡

'id' | never | never ➡

'id'

Обратите внимание, что вы делали:

type SetNonStringToNever<T> = { [P in keyof T]: T[P] extends string ? T[P] : never };

на самом деле просто превращал значения нестроковых свойств в never значения свойств. Это не касалось клавиш. Ваш Thing станет {id: string, price: never, other: never}. И ключи у него такие же, как у Thing. Основное различие между этим и KeysMatching заключается в том, что вы должны выбирать ключи, а не значения (то есть P, а не T[P]).

Надеюсь, это поможет. Удачи!

В качестве дополнительного ответа:

Начиная с версии 4.1 вы можете использовать переназначение клавиш для альтернативного решения (обратите внимание, что основная логика не отличается от ответа jcalz). Просто отфильтруйте ключи, которые при использовании для индексации исходного типа не создают тип, присваиваемый целевому типу, и извлеките объединение оставшихся ключей с keyof:

type KeysWithValsOfType<T,V> = keyof { [ P in keyof T as T[P] extends V ? P : never ] : P };

interface Thing {
    id: string;
    price: number;
    test: number;
    other: { stuff: boolean };
}

type keys1 = KeysWithValsOfType<Thing, string>; //id -> ok
type keys2 = KeysWithValsOfType<Thing, number>; //price|test -> ok

площадка

Как справедливо заметил Михал Миних:

Оба могут извлекать объединение строковых ключей. Тем не менее, когда их следует использовать в более сложной ситуации - например, T extends Keys ... ‹T, X›, тогда TS не сможет хорошо понять ваше решение.

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

type KeysWithValsOfType<T,V> = keyof { [ P in keyof T as T[P] extends V ? P : never ] : P } & keyof T;

function getNumValueC<T, K extends KeysWithValsOfType<T, number>>(thing: T, key: K) {
    return thing[key]; //OK
}

Обновленная площадка