Comment fonctionnent les interfaces avec les signatures de construction ?

Question

J'ai du mal à comprendre comment fonctionnent les constructeurs de définition dans les interfaces. Il se peut que je comprenne mal quelque chose. Mais j'ai cherché des réponses pendant un bon moment et je n'ai rien trouvé à ce sujet.

Comment puis-je implémenter l'interface suivante dans une classe TypeScript :

interface MyInterface {
    new ( ... ) : MyInterface;
}

Anders Hejlsberg crée une interface contenant quelque chose de similaire à ceci dans cette vidéo (à environ 14 minutes). Mais je n'arrive pas à mettre cela en place dans une classe.

Je comprends probablement mal quelque chose, qu'est-ce que je ne comprends pas ?

EDITAR:

Pour clarifier. Avec "nouveau (...)" je voulais dire "n'importe quoi". Mon problème est que je n'arrive pas à faire fonctionner même la version la plus basique de ce système :

interface MyInterface {
    new () : MyInterface;
}

class test implements MyInterface {
    constructor () { }
}

Cela ne compile pas pour moi. J'obtiens "Class 'test' declares interface 'MyInterface' but does not implement it : Le type 'MyInterface' nécessite une signature de construction, mais le type 'test' n'en a pas" lorsque j'essaie de le compiler.

EDITAR:

Donc, après avoir fait des recherches un peu plus poussées, compte tenu des commentaires.

interface MyInterface {
    new () : MyInterface;
}

class test implements MyInterface {
    constructor () => test { return this; }
}

n'est pas un TypeScript valide et cela ne résout pas le problème. Vous ne pouvez pas définir le type de retour du constructeur. Il retournera "test". La signature de ce qui suit : class test { constructor () { } } semble être "new () => test" (obtenue en survolant "class" dans l'éditeur en ligne avec juste ce code collé). Et c'est ce que nous voulons et ce que je pensais que ce serait.

Quelqu'un peut-il fournir un exemple de cette situation ou d'une situation similaire où la compilation est effective ?

EDIT (encore...) :

J'ai peut-être trouvé une idée pour expliquer pourquoi il est possible de définir ceci dans une interface mais pas de l'implémenter dans une classe TypeScript :

var MyClass = (function () {
    function MyClass() { }
    return MyClass;
})();

interface MyInterface {
    new () : MyInterface;
}

var testFunction = (foo: MyInterface) : void =>  { }
var bar = new MyClass();
testFunction(bar);

S'agit-il donc uniquement d'une fonctionnalité de TypeScript qui vous permet d'interfacer javascript ? Ou est-il possible de l'implémenter en TypeScript sans avoir à implémenter la classe en javascript ?