Definición del tipo de devolución de llamada de TypeScript

Tengo la siguiente clase en TypeScript:

class CallbackTest
{
    public myCallback;

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

Estoy usando la clase así:

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

El código funciona, por lo que muestra un cuadro de mensaje como se esperaba.

Mi pregunta es: ¿Hay algún tipo que pueda proporcionar para mi campo de clase myCallback? En este momento, el campo público myCallbackes del tipo anyque se muestra arriba. ¿Cómo puedo definir la firma del método de la devolución de llamada? ¿O puedo establecer el tipo en algún tipo de devolución de llamada? ¿O puedo hacer menos de estos? ¿Tengo que usar any(implícito / explícito)?

Intenté algo como esto, pero no funcionó (error en tiempo de compilación):

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

No pude encontrar ninguna explicación a esto en línea, así que espero que me puedan ayudar.

Acabo de encontrar algo en la especificación del lenguaje TypeScript, es bastante fácil. Estaba bastante cerca.

La sintaxis es la siguiente:

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

En mi ejemplo, sería

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

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

Para ir un paso más allá, puede declarar un puntero de tipo a una firma de función como:

interface myCallbackType { (myArgument: string): void }

y úsalo así:

public myCallback : myCallbackType;

Puedes declarar un nuevo tipo:

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

var handler: MyHandler;

Actualizar.

La declarepalabra clave no es necesaria. Debe usarse en los archivos .d.ts o en casos similares.

Aquí hay un ejemplo: no aceptar parámetros y no devolver 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();

Si desea aceptar un parámetro, también puede agregarlo:

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

Y si desea devolver un valor, también puede agregarlo:

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

Si desea una función genérica, puede usar lo siguiente. Aunque no parece estar documentado en ningún lado.

class CallbackTest {
  myCallback: Function;
}   

Puedes usar lo siguiente:

1. Escriba Alias ​​(usando la typepalabra clave, aliasing una función literal)
2. Interfaz
3. Función literal

Aquí hay un ejemplo de cómo usarlos:

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;

    // ...

}

Encontré el mismo error al intentar agregar la devolución de llamada a un detector de eventos. Curiosamente, establecer el tipo de devolución de llamada en EventListener lo resolvió. Parece más elegante que definir una firma de función completa como un tipo, pero no estoy seguro de si esta es la forma correcta de hacerlo.

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);
    }
}

Llego un poco tarde, pero desde hace algún tiempo en TypeScript puede definir el tipo de devolución de llamada con

type MyCallback = (KeyboardEvent) => void;

Ejemplo de uso:

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

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