¿Cómo devolver los tipos de las claves de una interfaz en TypeScript?

Tengo interface

interface Some {
  key1: string
  key2: number
}

Hay una función.

const fn = (key: keyof Some) => {
   return <Some>someObject[key]
}

¿Puedo obtener el tipo de retorno mediante una clave de cadena?

fn(‘key1’) // can ts know that it will return `string`?
fn(‘key2’) // can ts know that it will return `number`?

ACTUALIZADO :

¡Gracias @captain-yossarian por la respuesta! Ahora tengo un caso un poco más extendido.

export const getConfig = <T extends EntityInitialConfig, K extends keyof T> (key?: K) => {
  let config: T = window.someObject

  return key ? config[key] : config
}

getConfig('clientKey') // ts shows `string | EntityInitialConfig`

Y es un problema porque solo se necesita string. ¿Cómo hacerlo?

Respuesta #1

Asumo que estás buscando la siguiente solución:

const fn = <T extends unknown, K extends keyof T>(obj: T, key: K): T[K] => {
    return obj[key]
}

const result = fn({ name: 'John', age: 42 }, 'name') // string
const result2 = fn({ name: 'John', age: 42 }, 'age') // number

[ACTUALIZACIÓN] Tu función espera que el argumento key sea indefinido, definitivamente deberías proporcionar un valor predeterminado.

Si estás de acuerdo con el valor predeterminado, entonces deberías agregar sobrecargas de función.

interface EntityInitialConfig {
    age: number;
    name: string;
}

const config: EntityInitialConfig = { age: 42, name: 'John' };

interface GetConfig {
    (key: undefined): EntityInitialConfig['name'] // it is kinda default value
    <K extends keyof EntityInitialConfig>(key: K): EntityInitialConfig[K]

}
export const getConfig: GetConfig = <K extends keyof EntityInitialConfig>(key?: K) => {
    return key ? config[key] : config
}

const x = getConfig('age') // ts shows number

P.D. No estoy seguro de si es la sintaxis correcta: return <Some>someObject[key]