interface I {
    property: number;
    method1(): void;
    method2(a: string): number; 
}

declare const ob: I;

declare function foo<T, K extends keyof T>(ob: T, key: K): T[K];

const f1 = foo(ob, 'property'); // number
const f2 = foo(ob, 'method1'); // () => void
const f3 = foo(ob, 'method2'); // (a: string) => number

// f1(); OK, not a function
f2();
f3('a string');

type FunctionPropertyNames<T> = { [K in keyof T]: T[K] extends Function ? K : never }[keyof T];

declare function bar<T, K extends FunctionPropertyNames<T>>(ob: T, key: K): T[K];

// const f4 = bar(ob, 'property'); OK, 'property' is not allowed  
const f5 = bar(ob, 'method1'); // () => void | (a: string) => number
const f6 = bar(ob, 'method2'); // () => void | (a: string) => number

// ERROR! Both are of type '() => void | (a: string) => number'
f5();
f6('a string');

// Type assertion
const f7 = bar(ob, 'method1' as 'method1'); // () => void
const f8 = bar(ob, 'method2' as 'method2'); // (a: string) => number

// OK again
f7();
f8('a string');