Generics 访问typescript泛型键

考虑以下类型脚本：

接口XInput{xin:number；}
接口XOutput{xout:number；}
接口YInput{yin:number；}
接口YOutput{yout:number；}
接口FMap{
getX：任何；
盖蒂：任何；
}
接口输入映射扩展了FMap{
getX:XInput；
盖蒂：印普特；
}
接口OutputMap扩展了FMap{
getX:XOutput；
getY:YOutput；
}
类方法字典{
私有_方法：any={}；
定义（名称：N，fn:（a:MI[N]）=>MO[N]）{
这._方法[名称]=fn；
}
呼叫（名称：N，输入：MI[N]）{
此._方法[名称]（输入）；
}
}
const mapper=new MethodDictionary（）；
define（'getX'，（a:XInput）：XOutput=>{return{xout:0}；}）；
调用（'getX'，{xin:0}）；

在本例中，我希望定义一个函数映射器，它接受函数的名称，并强制我们定义接受一些输入并给出一些输出的函数。在这种情况下，我想强迫自己写作 以下功能：

接口方法{
getX：（a:XInput）=>XOutput；
盖蒂：（a:YInput）=>YOutput；
}

我本可以写以下内容：

类其他映射器{
私有_方法：any={}；
定义（名称：N，fn:M[N]）{
这._方法[名称]=fn；
}
}

我也会达到上述的效果。也就是说，如果我们要写：

mapper.define（'otherKey'，…）

typescript会让我们知道只允许

getX | getY

。如果我们要更改函数的输入或输出，它也会警告我们

但是我无法为

调用
方法编写定义。你们是否看到了一种方法，我们可以简化工作示例，这样typescript仍然可以警告我们使用的类型，并且有一种方法可以定义一个更简单的契约？也就是说，我们可以定义

接口方法映射{
getX:[XInput，XOutput]；
盖蒂：[音普特，你普特]；
}

并将其用作映射器的唯一通用参数？我想写这篇文章，但没用：

类方法字典{
私有_方法：any={}；
定义（名称：N，fn:（a:M[N][0]）=>M[N][1]）{
这._方法[名称]=fn；
}
呼叫（名称：N，输入：M[N][0]）{
此._方法[名称]（输入）；
}
}
接口XInput{xin:number；}
接口XOutput{xout:number；}
接口YInput{yin:number；}
接口YOutput{yout:number；}
类型字典函数={
[P in keyof T]：{
参数：任意；
退货：任何；
}
}
类方法字典{
私有_方法：any={}；
定义（名称：N，fn:（a:M[N]['parameter']）=>M[N]['returns']）{
这._方法[名称]=fn；
}
调用（名称：N，输入：M[N]['parameter']）{
此._方法[名称]（输入）；
}
}
接口FMap{
getX:{
参数：XInput，
返回：XOutput
};
格蒂：{
参数：YInput，
返回：YOutput，
};
}
const mapper=new MethodDictionary（）；
define（'getX'，（a:XInput）：XOutput=>{return{xout:0}；}）；
调用（'getX'，{xin:0}）；

interface XInput { xin: number; }
interface XOutput { xout: number; }
interface YInput { yin: number; }
interface YOutput { yout: number; }

type DictionaryFunction<T> = {
  [P in keyof T]: {
    parameter: any;
    returns: any;
  }
}

class MethodDictionary<M extends DictionaryFunction<M>> {
  private _methods: any = {};

  define<N extends keyof M>(name: N, fn: (a: M[N]['parameter']) => M[N]['returns']) {
    this._methods[name] = fn;
  }

  call<N extends keyof M>(name: N, input: M[N]['parameter']) {
    this._methods[name](input);
  }
}

interface FMap {
    getX: {
        parameter: XInput,
        returns: XOutput
    };
    getY: {
        parameter: YInput,
        returns: YOutput,
    };
}

const mapper = new MethodDictionary<FMap>();
mapper.define('getX', (a: XInput): XOutput => { return { xout: 0 }; });
mapper.call('getX', { xin: 0 });