Typescript: スプレッド演算子を使用すると、コンパイラがパラメータ/呼び出しターゲットのシグネチャの不一致を誤って報告します

argsがanyタイプの場合も同様です。

function foo(x: number, y: number, z: number) { }

function bar(...args) {
    foo(...args); // Supplied parameters do not match any signature of call target.
}

これは現在、設計によるものです。 しかし、私たちはそれを再考する必要があります。

@ smashdevcode 、 @ tjoskar 、私はこの機能の実際の使用法を探しています。 具体的には、配列またはタプル（または両方）を拡散することを期待していますか？ おもちゃの例をいくつか示します。

//// arrays ////
var a1: number[] = [1,2];
var a2: number[] = [1,2,3];
var a3: number[] = [];
function twoNumbersOrSo(n?: number, m?: number) {
  return (n || -1) * (m || -1);
}
function howManyNumbersLessOne(n?: number, ...ns: number[]) {
    return ns.length;
}

//// tuples ////
var t1: [number, string] = [1, "foo"];
var t2: [number, string, string] = [1, "foo", "bar"];
function veryTraditional(n: number, s: string) {
    for (let i = 0; i < n; i++) {
        console.log(s);
    }
}
function moreInteresting(n: number, s: string, ...rest: string[]) {
    veryTraditional(n, s);
    console.log(rest);
}

これで、 a1,a2,a3いずれかを最初の2つの関数に適用でき、 t1,t2いずれかを次の2つの関数に適用できます。

配列の場合：

1. 単一のタイプがあるため、パラメーターはすべて同じタイプである必要があります。 （これはanyなる可能性があると思います。）
2. 配列の長さはコンパイル時にわからないため、パラメーターはオプションである必要があります。 そして、スプレッドの議論は（今日のように）最後でなければなりません。

タプル付き：

1. 値には、ある時点で型注釈が必要になります。 それ以外の場合は、配列として解釈されます（たとえば、 (number | string)[]ではなく[number, number, string] ）。 おもちゃのコードでは、これにより簡潔さの節約が失われますが、すでに多くのインターフェイスを定義している実際のプロジェクトでは問題ない場合があります。
2. 長さは事前にわかっているので、タプルはあらゆる種類のパラメーターリストに適用できます。

こんにちは@sandersn 、

返信が遅くなってすみません。 私はあなたの返事を完全に逃しました。
私は1つのデータ型の配列のみを使用しているため、タプルバージョンはあまり興味がありません。
ただし、関数呼び出しのspread操作は、反復可能なオブジェクトを受け入れる必要があると思います。 したがって、たとえばで動作するはずです。 mapとset 。これらの場合、データに複数のデータ型が含まれている場合でも、spread演算子と連携するインターフェイスを作成する必要があります（例：new Set（）。add（1） .add（ 'string'））。 しかし、それは多分別のチケットですか？

Setとスプレッド操作の例（Chrome 46で機能）

function foo(...args) {
    console.log(...args);
}
var bar = new Set().add(1).add(2);

foo(...bar); // 1, 2

ええ、それは別の問題です。 Typescriptは、残りのパラメーターの型として配列をすでにサポートしています。これは、汎用にする必要があるものです。 スプレッド引数を使用できる場所について説明しているだけです。

同種の配列/セットをrest-parametersを持つ関数に渡しますか、それとも固定数の引数を持つ関数に渡しますか？ あなたが呼ぶことについてもっと詳しく知りたいのですが。

まず、今朝、spread演算子をいじってみましたが、ほとんどのユースケースは、最新バージョンのtypescript [email protected]とhttp://www.typescriptlang.org/Playgroundで正常に機能し

しかしながら、
使用できるようにするためだけにすべてのパラメーターをオプションにするという考えは好きではありません
スプレッド演算子しかし、私は問題を理解しています。 配列の長さはコンパイル時にわからないため、
コンパイル時にパラメータを確認することはできません。

ただし、パラメータがオプションである必要がなく、コンパイラがあればいいと思います。
「spread-variable」が正しいタイプであることを確認するだけです。 数[]

function fun1(x: number, y: number, z: number) {
    return x+y+z;
}

let arr1 = [1, 2, 3];
let arr2 = [1, 2];

fun1(...arr1);
fun1(...arr2); // OK since `arr2` is number[]
fun1(1, 2); // Should cause an error

それは可能ですか？

次のコードは、現在のバージョンのtypescriptで機能しますが、この問題が解決されたときには機能しませんでした。

function fun1(...num) {
    return Math.max(...num);
}

function fun2(a1, ...num) {
    return Math.max(...num);
}

function fun3(a1, ...num) {
    return fun1(...num);
}

let arr = [1, 2, 3];

if (Math.random() < .5) {
    arr.push(1);
}

fun1(...arr);
fun2('first param', ...arr);
fun3('first param', ...arr);

たぶんもっと現実的な例（今日でも機能します）：

const doSomeWork = ({title, genre, runtime}) => { console.log(title, genre, runtime); };

function fun1(...num) {
    num.forEach(doSomeWork);
}

const data = [{
    title: 'title',
    genre: ['action', 'drama'],
    runtime: 100
}];

fun1(...data);

：+1： Dateコンストラクターの特定のユースケースで同じ問題が発生します：

let dateNumberArray: Array<number> = [2015,11,11];
let myNewDate = new Date(...dateNumberArray);

私たちの場合、スプレッドを使用して、ユーザーが独自のヘルパーを作成しなくても、ベースアプリでargv要件を構成できるようにします。 例えば：

{
  "yargv": [
    [
      "path",
      {
        "demand": true,
        "describe": "Source",
        "default": ".",
        "alias": "p"
      }
    ]
  ]
}

get appArgs() : { yargv: Array<Array<any>>, chdir: Array<boolean | string> } {
  return require(
    "../args.json"
  )
}

argv() : Promise<{}> {
  return new Promise((resolve) => {
    this.appArgs.yargv.forEach(v => yargs.option(...v))
    return resolve(yargs.usage("$0 [args]").help("h").
      alias("h", "help").argv)
  })
}

https://github.com/ReactiveX/rxjsのcombineLatest関数を使用した実際の例では、矢印関数を使用してprojectFnを呼び出し、残りのパラメーターを使用してthis値を保持します。引数を伝播します。

getCombination() {
    return this.firstObservable
      .combineLatest(this.secondObservable, (...args) => this.projectFn(...args)));
  }

現在私はしなければなりません

getCombination() {
    return this.firstObservable
      .combineLatest(this.secondObservable, (...args) => this.projectFn.apply(this, args)));
  }

FWIW、別の実世界の例は、lodashからのマージを使用してオブジェクトの配列をディープマージしようとしています。

import { merge } from 'lodash';

...
return merge(...arrayOfObjects);

これが別の実際のユースケースです。 次のようなコードをリファクタリングしようとしています。

return Observable
      .forkJoin(a, b)
      .map(([current, past]) => this.mergeData(current, past));

もう少しエレガントに：

return Observable
      .forkJoin(a, b)
      .map(data => this.mergeData(...data));

ただし、spread演算子を使用すると、署名の不一致エラーが発生します。

もう一つの例

class Parent {
    constructor(a, b, c){

    }
}

class Child extends Parent {
    constructor(d, ...args) {
        super(...args);
    }
}

TS2346：指定されたパラメータがコールターゲットのどのシグニチャとも一致しません。

オーバーロードメソッドに関する同じ問題：

listen(port: number, hostname?: string, backlog?: number, listeningListener?: Function): Server;
listen(port: number, hostname?: string, listeningListener?: Function): Server;
listen(port: number, backlog?: number, listeningListener?: Function): Server;
listen(port: number, listeningListener?: Function): Server;
listen(path: string, backlog?: number, listeningListener?: Function): Server;
listen(path: string, listeningListener?: Function): Server;
listen(options: ListenOptions, listeningListener?: Function): Server;
listen(handle: any, backlog?: number, listeningListener?: Function): Server;
listen(handle: any, listeningListener?: Function): Server;

と呼ばれている間

myListen(...args) {
    listen(...args);
}

次に：_ [ts]指定されたパラメータがコールターゲットのどのシグネチャとも一致しません。_

したがって、今のところ、そのようなことを行うことは不可能です。

export type DateProp = Date | (string|number)[];

const setDate = (value: DateProp): Date => (
    isDate(value) ? value : new Date(...value)
);

エラーが発生しているため：

指定されたパラメータは、コールターゲットのどのシグニチャとも一致しません。

値に正しい日付コンストラクターパラメーター値が含まれている場合でも

値に正しい日付コンストラクターパラメーター値が含まれている場合でも

それは正しいです、これはこの問題が追跡しているものです。

なんとかして助けたり貢献したりできるかどうか尋ねる義務があると感じています。 もし今なら、なぜこの場合にエラーを引き起こしているのか詳しく説明できますか？ 設定で何とかスキップできますか？

.jsファイルの名前を.tsに変更したときに、実際にこの問題が発生しました。 とにかく、「すべての有効なJSが有効なTSであるとは限らない」という一例。

現在、styled-componentのメディアテンプレートの例を実装する際にこの問題が発生しています。

import {css} from 'styled-components';

export const Breakpoints = {
    tablet: 580,
    desktop: 800,
};

export type BreakpointLabels = keyof typeof Breakpoints;

export const media = Object.keys(Breakpoints).reduce((mediaQueries, label: BreakpointLabels) => (
    {
        ...mediaQueries,
        [label]: (...args: any[]) =>
            css`
                <strong i="7">@media</strong> (max-width: ${Breakpoints[label]}px) {
                    ${css(...args)}
                      ^^^^^^^^^^^^ Supplied parameters do not match any signature of call target.
                }
            `
    }
), {});

私の回避策はcss.callを使用することです。これは、少なくともany[]タイプの引数で機能します。

import {css} from 'styled-components';

export const Breakpoints = {
    tablet: 580,
    desktop: 800,
};

export type BreakpointLabels = keyof typeof Breakpoints;

export const media = Object.keys(Breakpoints).reduce((mediaQueries, label: BreakpointLabels) => (
    {
        ...mediaQueries,
        [label]: (...args: any[]) =>
            css`
                <strong i="13">@media</strong> (max-width: ${Breakpoints[label]}px) {
                    ${css.call(this, ...args)}
                }
            `
    }
), {});

同じ問題、私の例は基本的なマージ関数です：

merge(target: T, ...sources: T[])

少なくともファイルごとにこのエラーをミュートする方法はありますか？

実際、このES6の可能性が、再考される可能性があるときに、設計または計画によって破られる理由を知りたいと思います。 @mhegazyコメントしてください。

最近、ターゲットがすべてオプションの場合に呼び出し式に拡散できるように変更を加えました（https://github.com/Microsoft/TypeScript/pull/15849を参照）。 この変更は、スプレッド出力をオプションの引数の無限セットとして扱うことで機能します。

この変更により、例の現在の状態は次のようになります。

declare var args: number[];

function foo(x?: number, y?: number, z?: number) { }
foo(...args);     // OK
foo(2, ...args);  // OK

function bar(...args: number[]) { }
bar(...args);     // OK
bar(2, ...args);  // OK

function baz(x: number, y: number, z: number) { }
baz(...args);     // still not allowed

最後の例では、 argsの長さを静的に検証できないため、コンパイラーはargsが必要なbaz満たしていることを検証する方法がありません。

この領域に残されているのは、既知のサイズのタプルが同じ長さの必須の引数を持つ関数を満たすことができるようにすることです。しかし、これは思ったほど単純ではありません。 例えば：

function baz(x: number, y: number, z: number) { }
var tuple: [number, number, number] = [1, 2, 3];
baz(...tuple);     // should be allowed

@devrelmと同じ問題があり

私はまだこれに問題があります、何が問題なのですか？

class A {
    constructor(message: string, test?: any) {
        console.log('A constructor called');
    }
}

class B extends A {
    constructor(...spread) {
        super('a', ...spread);
    }
}

タイプスクリプトの遊び場でエラーが発生します

@owlcodeこれはTS2.3にあります。

これはTS2.4で修正されているようです。

export function log(...args: any[]) {
    console.log(...join(args.map(formatDevTools),' '));
}

ただし、 TS2.4には新しいバグがあるようです。

TS2461：タイプ '反復可能'は配列型ではありません。

反復可能（ [...obj] ）を広めようとすると発生します。

それでも、 2.4.1-insiders.20170615にはまだ別のバグ（私は思う）がありますが、私はまだ理解できていません。

これを回避する方法もわかりません。 配列をany[]キャストしても効果はありません。

気にしないでください、 Consoleの定義を修正できます、

interface _Console {
    assert(test?: boolean, message?: string, ...optionalParams: any[]): void;
    clear(): void;
    count(countTitle?: string): void;
    debug(...optionalParams: any[]): void;
    dir(value?: any, ...optionalParams: any[]): void;
    dirxml(value: any): void;
    error(...optionalParams: any[]): void;
    exception(message?: string, ...optionalParams: any[]): void;
    group(groupTitle?: string): void;
    groupCollapsed(groupTitle?: string): void;
    groupEnd(): void;
    info(...optionalParams: any[]): void;
    log(...optionalParams: any[]): void;
    msIsIndependentlyComposed(element: Element): boolean;
    profile(reportName?: string): void;
    profileEnd(): void;
    select(element: Element): void;
    table(...data: any[]): void;
    time(timerName?: string): void;
    timeEnd(timerName?: string): void;
    trace(...optionalParams: any[]): void;
    warn(...optionalParams: any[]): void;
}

次に、 consoleオブジェクトをキャストします。

export function log(...args: any[]) {
    (console as _Console).log(...join(args.map(formatDevTools),' '));
}

それは今のところやらなければならないでしょう。

＃18004でPRを始めました。

今のところ、tsconfigで"noStrictGenericChecks"を有効にする必要があります。

今のところ、tsconfigで「noStrictGenericChecks」を有効にする必要があります。

これがこのバグとどのように関連しているかわかりません...

これがこのバグとどのように関連しているかわかりません。

@mhegazyこの設定はすべての関数シグネチャを無効にするため、引数の量を一致させずに（少なくとも静的ではなく）spread演算子を使用して引数を渡すことができます

それは--noStrictGenericChecks行うことではありません。 https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#stricter-checking-for-generic-functionsを参照して

私はちょうどこれに出くわしました。

難しいことは理解できますが、少なくとも「過剰な」議論は特定できるはずです。

@sandersnは、実世界の観点から、rest引数を使用する代わりに、単一の引数または配列を受け入れるようにAPIをリファクタリングしていました。 したがって、 foo(value, ...otherValues)ようなものを渡す状況は、エラーとして識別されていませんでした。 特にこれは本当に危険なようです：

declare const foo: (value: string) => string;

foo('bar', 'qat'); // Expected 1 arguments, but got 2.

foo('bar', ...['qat']); // No error

@kitsonkそのための別のバグを開くことができますか？ 単独で検討する方が簡単であり、複雑な変更ではなく、既存のルールを少し調整するだけです。

長さを確認しても、次のエラーが発生します。

function myFunc(...args: any[]) {
  if(args.length > 0) {
    otherFunc(...args)
  }
}

編集：

混乱を解消するために、私はここからリダイレクトされ

2つの引数が必要ですが、最小値は0です。

その問題は、この問題の重複と見なされました。

私の場合、次のように初期化子の1つとしてfunction otherFunc()を追加することで、メソッドに何も渡されないようにすることで、エラーを修正できました（修正というよりはハックのようです）。

function otherFunc()
function otherFunc(arg1: string)
function otherFunc(arg1: string, arg2: number)
function otherFunc(...args: any[]) {
  // Do stuff
}

この回避策は2.7で壊れます

これはまだどのように問題ですか？ スプレッド演算子はJSで機能するための完全に準拠した方法であるため、TSはそれを適切に考慮する必要があります。

@ jpike88いい意味だと思いますが、このような発言は逆効果だとは思わないかもしれません。 問題は、マイルストーン2.7または2.8のTODOにあります。 修正するのは明らかなことのように思えるかもしれませんが、修正する明白なものが何千もある場合、それらすべてを同時に修正することはできず、それらに期待される他のことを改善し続けることはできません。 投票を表明する最良の方法は、上部の元の投稿に👍反応を与えることです。 これは結局のところフリーソフトウェアであり、彼らは私たちに何も借りていません。 そうは言っても、それは私の見解です、別のユーザー
あなたのようなTSの🕺

もう1つの優れたテストケース（実際にはTS 2.7のリグレッション）は次のとおりです。

class NonEmptyArray<T> extends Array<T> {
        0: T;
}

function c(firstArg: string, ... plainValues: string[]): string;
function c(): undefined;
function c(...values: string[]): string | undefined {
        if (!values.length) {
                return undefined;
        }
        return "";
}


function d(): NonEmptyArray<string> {
        return [""];
}

function y(): string | undefined {
        return c(...d());
}

それは生成します

test.ts（20,9）：エラーTS2557：少なくとも0個の引数が必要ですが、0個以上を取得しました。

スプレッド演算子に関して私が遭遇した別の問題：

const get = (id?: string = '1231254', bar?: Bar, baz?: Baz) => {...}
const foo: [undefined, Bar, Baz] = [undefined, bar, baz]

get(...foo) // [ts] Argument of type 'Bar | Baz' is not assignable to parameter  
of type 'string'.
Type 'Baz' is not assignable to type 'string'

もちろん、ES6では、引数として未定義が含まれている配列を拡散し、 undefinedを適切に渡すことに問題はありませんが、TSはundefined値を拡散するときに無視しているようです。

関数呼び出しでspread演算子を正しく処理すると、次のような実例があります。
NSwagStudioによって生成された関数があります-C＃WebApiのAPIジェネレーターで、同じパラメーターがあります（GETパラメーターは構造で定義されています）

生成された関数は次のようになります。

export interface ITableApiClient {
    getTableInfo(objnam: string | null, objsch: string | null | undefined, dbnam: string | null, conid: number | undefined): Promise<FileResponse | null>;
    otherFunction(objnam: string | null, objsch: string | null | undefined, dbnam: string | null, conid: number | undefined): Promise<string | null>;
}

構文で呼びたい

   get tableIdentification() {
       return [this.name, this.schema, this.databaseName, this.serverConnectionId];
   }
...
   return apiClient.getTableInfo(...this.tableIdentification);

   // this doesn't help, still compile-time error
   // return apiClient.getTableInfo(...(this.tableIdentification as any));

まったく同じパラメーターを持つ関数が他にもあるためです（C＃バックエンドで定義された同じパラメータークラスから生成されるため）。 次に、プロパティtableIdentificationの本体を各使用法にn回コピーする必要があります

@smashdevcode私にとっての解決策は、@ ts-ignoreを追加することでした

function foo(x: number, y: number, z: number) { }
var args = [0, 1, 2];
// @ts-ignore
foo(...args);

ここでの例： https ：

@ darekf77 、またはargsがタプルであると言う場合：

function foo(x: number, y: number, z: number) { }
const args: [number, number, number] = [0, 1, 2];
foo(...args);

ts-遊び場

@ darekf77 、またはargsがタプルであると言う場合：

function foo(x: number, y: number, z: number) { }
const args: [number, number, number] = [0, 1, 2];
foo(...args);

これは、コマンドラインでタイプスクリプトをコンパイルするときに機能しますが、入力中にVisual StudioCodeがタイプスクリプトを検証するときは機能しません。 ここで切断が何であるかわかりません。

jayphelpsがこれは次のリリースで修正されると述べてから1年以上が経過しているようですが、この問題は引き続き発生します。 これに関する更新はありますか？ @ ts-ignoreを使用できることはわかっていますが、これにより関数のすべてのtypescriptメッセージが削除されるため、実際には適切な解決策ではありません。

tjoskarが述べた@TidyIQは、スプレッド配列をタプルとしてタイプキャストします。

配列は固定長ではないため、機能しません。

タイプキャストは、たとえそれが不正確であっても、コンパイラーに関する限り機能します。 私はそれが最善の解決策ではないことに同意します。

（この質問はおそらくスタックオーバーフロー（または同様のもの）に移動する必要があります）

@TidyIQ 、配列に固定長がない場合、コンパイラは配列が適切かどうかを判断できません。

function foo(x: number, y: number, z: number) { }
const args = arrayOfSomeLength;
foo(...args); // Error: The compiler do not know if there is 3 or 2 or 1 or 50 elements in the array. 

したがって、配列が動的な長さである場合、引数も次のようになります。

function foo(...args: number[]) { }
const args = arrayOfSomeLength;
foo(...args);

遊び場

残念ながら、私の引数のいくつかは固定長であるため、それも機能しません。

おそらく、コードを投稿するだけで問題が発生する可能性があります。

interface IF_Object {
  [key: string]: object;
}
//  VALUE SHOULD BE REQUIRED BUT MADE OPTIONAL TO BYPASS TYPESCRIPT ERROR
interface IF_SetKV {
  (key: string, value?: any): Function;
}
//  VALUE SHOULD BE REQUIRED BUT MADE OPTIONAL TO BYPASS TYPESCRIPT ERROR
interface IF_CreateState {
  (key: string, value?: any, ...more: string[]): Function;
}

const setKV: IF_SetKV = (key, value) => (object: IF_Object = {}) => ({
  ...object,
  [key]: value
});

const createState: IF_CreateState = (key, value, ...more) => (
  object: IF_Object = {}
) =>
  more.length === 0
    ? setKV(key, value)(object)
    : setKV(key, createState(value, ...more)(object[key]))(object);

// TYPESCRIPT ERROR OCCURS HERE. CAN ONLY BE REMOVED WITH TS<strong i="7">@IGNORE</strong>
const newState = createState(...stateList, action.payload.value)(reduced);

@TidyIQ 、フォローしているかどうかstateListが空の配列の場合はどうなりますか？ その場合、 action.payload.valueはkeyとして渡されますか？

これは機能しないはずです：

const createState = (...args: string[]) => (object: IF_Object = {}) => {
  const [key, value, ...rest] = args;
  if (rest.length === 0) {
    setKV(key, value)(object)
  } else {
    setKV(key, createState(value, ...rest)(object[key]))(object);
  }
}

引数を渡す関数のParameterTypeとして値を拡散するようにキャストします。

const add = (a: number, b: number) => a + b

const values = {
  a: 1,
  b: 2,
}

type AddParams = Parameters<typeof add>

add(...(values) as AddParams)

@ mateja176これも機能しているようで、いくつかのユースケースに適している可能性があります。

add(...(values as [number,number]))

または

add(...(values as [any,any]))

これにはヘルパー型を使用して、明示的に入力しなくても任意の配列を処理します。

type NonEmptyArray<T extends any[]> = T extends (infer U)[]
  ? [U, ...U[]]
  : never

これは次のように使用できます。

add(...values as NonEmptyArray<typeof values>)

次のNonEmptyArrayタイプの分析では、その仕組みについて詳しく説明しています。

＃| パート| 説明
-|-|-
（1）| type NonEmptyArray | ヘルパータイプの名前
（2）| <T | ヘルパー型はジェネリック型パラメーターT取ります。
（3）| extends any[]> | 型チェッカーで受け入れられるには、その型パラメーターTが何らかの配列型である必要があります。
（4）| T extends (infer U)[] ? | ヘルパー型は、 T実際に配列型であるかどうかをチェックする条件型です。
（3）でTを配列型として宣言したので、この条件は常に通過しますが、条件を使用すると、TypeScript inferにT配列の型を許可できます。で構成されており、その型をUと呼びます。
（5）| [U, ...U[]] | これで、結果の型をアセンブルできます。最初のエントリの型がUで、残りの（0個以上の）エントリも型U配列です。
この特定のタプル表記のため、TypeScriptは少なくとも1つの項目があることを認識しています。
（6）| : never | これは、構文的に条件を完了するために必要です。 注意：条件はU型を抽出するための単なるトリックであり、常に合格します。 したがって、 neverを生成することで、「else」ブランチを安全に無視できます。

今これを行うと...

ts const values = [1,2,3] add(...values as NonEmptyArray<typeof values>)

...次のことが起こります：

• typeof valuesは、TypeScriptがvalues配列（数値の配列number[]に対して推測したタイプです。
• つまり、 number[]をTとして渡します。 （2/3）
• Tは確かに配列型なので、そこからUを推測できます。これはnumberです。 （4）
• Uがnumberであることがわかったので、タイプ[number, ...number[]]ます。 （5）
  

@tjoskarはコードをに変更します

function foo(x: number, y: number, z: number, f: number) { }
const args: [number, number, number] = [0, 1, 2];
foo(...args, 3);

（遊び場）
そして、エラーが戻ってきました。

驚いたことに、最後の行をfoo(3, ...args);に変更した場合、エラーは発生しません。

これはまだ機能していないように感じます。 これが私の例です

onSetValue={(...args: Parameters<typeof props.onSetValue>) => {
    setLanguage(null);
    props.onSetValue(...args); // Expected 2 arguments, but got 0 or more.
  }}

props.onSetValueのタイプが何であるかは実際には問題ではありません。パラメーターのタイプを取得して、タイプを取得した関数に渡すだけで、 Expected 2 arguments, but got 0 or more.エラーが発生するためです。 。

遊び場リンク

これは@ Haaxor1689の例の縮小形です：
遊び場リンク

私はまだそれを動作させることができません

これは私の一時的な回避策です

class Board {
  private events: Events

  public on(...args: Parameters<this['events']['on']>) {
    this.events.on.call(this.events, ...args)
  }
}