TypeScript autorise-t-il les alias de type?

Je souhaite donc pouvoir utiliser un alias pour un type laid qui ressemble à ceci:

Maybe<Promise<Paged<Carrier>, Problem>>[]

Quelque chose comme:

import Response = Maybe<Promise<Paged<Carrier>, Problem>>[];

Existe-t-il un moyen de faire des alias de type dans TypeScript?

Depuis la version 1.4, Typescript prend en charge les alias de type ( source ).

Alias ​​de type

Vous pouvez maintenant définir un alias pour un type à l'aide du mot-clé type:

type PrimitiveArray = Array<string|number|boolean>;
type MyNumber = number;
type NgScope = ng.IScope;
type Callback = () => void;

Les alias de type sont exactement les mêmes que leurs types d'origine; ce sont simplement des noms alternatifs.

Et à partir de la version 1.6, Typescript prend en charge les alias de type générique ( source ).

Alias ​​de type générique

Avant TypeScript 1.6, les alias de type étaient limités à de simples alias qui raccourcissaient les noms de type longs. Malheureusement, sans pouvoir les rendre génériques, leur utilisation était limitée. Nous autorisons maintenant les alias de type à être génériques, ce qui leur donne une capacité d'expression complète.

type switcharoo<T, U> = (u: U, t:T)=>T;
var f: switcharoo<number, string>;
f("bob", 4);

TypeScript prend en charge les importations, par exemple:

module A {
    export class c {
        d: any;
     }
}

module B {
    import moduleA = A;

    var e: moduleA.c = new moduleA.c();
}

module B2 {
    import Ac = A.c;

    var e: Ac = new Ac();
}

Mise à jour 1

Depuis TS 1.4, nous pouvons utiliser des déclarations de type:

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

var handler: MyHandler;

Depuis TS 1.6, nous pouvons utiliser des déclarations de type local:

function f() {
    if (true) {
        interface T { x: number }
        let v: T;
        v.x = 5;
    }
    else {
        interface T { x: string }
        let v: T;
        v.x = "hello";
    }
}

La solution d'un pauvre est de déclarer une variable factice (par exemple t) avec le type souhaité et d'utiliser à la typeof tplace de l'expression de type long:

var t: {(x: nombre, f: {(foo: string, bar: boolean): void}): void};

var f: type de t;
var g: type de t;