Definindo o tipo de retorno de chamada TypeScript

Eu tenho a seguinte classe no TypeScript:

class CallbackTest
{
    public myCallback;

    public doWork(): void
    {
        //doing some work...
        this.myCallback(); //calling callback
    }
}

Estou usando a classe assim:

var test = new CallbackTest();
test.myCallback = () => alert("done");
test.doWork();

O código funciona e, portanto, exibe uma caixa de mensagens conforme o esperado.

Minha pergunta é: Existe algum tipo que eu possa fornecer para o meu campo de classe myCallback? No momento, o campo público myCallbacké do tipo anyconforme mostrado acima. Como posso definir a assinatura do método do retorno de chamada? Ou posso apenas definir o tipo para algum tipo de retorno de chamada? Ou posso fazer nada disso? Eu tenho que usar any(implícito / explícito)?

Eu tentei algo assim, mas não funcionou (erro em tempo de compilação):

public myCallback: ();
// or:
public myCallback: function;

Não encontrei nenhuma explicação para isso on-line, então espero que você possa me ajudar.

Acabei de encontrar algo na especificação da linguagem TypeScript, é bastante fácil. Eu estava bem perto.

a sintaxe é a seguinte:

public myCallback: (name: type) => returntype;

No meu exemplo, seria

class CallbackTest
{
    public myCallback: () => void;

    public doWork(): void
    {
        //doing some work...
        this.myCallback(); //calling callback
    }
}

Para ir um passo adiante, você pode declarar um ponteiro de tipo para uma assinatura de função como:

interface myCallbackType { (myArgument: string): void }

e use-o assim:

public myCallback : myCallbackType;

Você pode declarar um novo tipo:

declare type MyHandler = (myArgument: string) => void;

var handler: MyHandler;

Atualizar.

A declarepalavra-chave não é necessária. Ele deve ser usado nos arquivos .d.ts ou em casos semelhantes.

Aqui está um exemplo - não aceitando parâmetros e retornando nada.

class CallbackTest
{
    public myCallback: {(): void;};

    public doWork(): void
    {
        //doing some work...
        this.myCallback(); //calling callback
    }
}

var test = new CallbackTest();
test.myCallback = () => alert("done");
test.doWork();

Se você deseja aceitar um parâmetro, também pode adicioná-lo:

public myCallback: {(msg: string): void;};

E se você deseja retornar um valor, você pode adicionar também:

public myCallback: {(msg: string): number;};

Se você deseja uma função genérica, pode usar o seguinte. Embora não pareça estar documentado em nenhum lugar.

class CallbackTest {
  myCallback: Function;
}   

Você pode usar o seguinte:

1. Digite Alias ​​(usando a typepalavra-chave, alias uma literal de função)
2. Interface
3. Função Literal

Aqui está um exemplo de como usá-los:

type myCallbackType = (arg1: string, arg2: boolean) => number;

interface myCallbackInterface { (arg1: string, arg2: boolean): number };

class CallbackTest
{
    // ...

    public myCallback2: myCallbackType;
    public myCallback3: myCallbackInterface;
    public myCallback1: (arg1: string, arg2: boolean) => number;

    // ...

}

Me deparei com o mesmo erro ao tentar adicionar o retorno de chamada a um ouvinte de evento. Estranhamente, a configuração do tipo de retorno de chamada como EventListener o resolveu. Parece mais elegante do que definir uma assinatura de função inteira como um tipo, mas não tenho certeza se essa é a maneira correta de fazer isso.

class driving {
    // the answer from this post - this works
    // private callback: () => void; 

    // this also works!
    private callback:EventListener;

    constructor(){
        this.callback = () => this.startJump();
        window.addEventListener("keydown", this.callback);
    }

    startJump():void {
        console.log("jump!");
        window.removeEventListener("keydown", this.callback);
    }
}

Estou um pouco atrasado, mas, já há algum tempo, no TypeScript, você pode definir o tipo de retorno de chamada com

type MyCallback = (KeyboardEvent) => void;

Exemplo de uso:

this.addEvent(document, "keydown", (e) => {
    if (e.keyCode === 1) {
      e.preventDefault();
    }
});

addEvent(element, eventName, callback: MyCallback) {
    element.addEventListener(eventName, callback, false);
}