¿TypeScript permite los alias de tipo?

Así que me gustaría poder usar un alias para un tipo feo que se parece a esto:

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

Algo como:

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

¿Hay alguna forma de hacer alias de tipo en TypeScript?

Desde la versión 1.4, Typescript admite alias de tipo ( fuente ).

Alias ​​de tipo

Ahora puede definir un alias para un tipo usando la palabra clave type:

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

Los alias de tipo son exactamente iguales a sus tipos originales; son simplemente nombres alternativos.

Y desde la versión 1.6, TypeScript admite alias de tipo genérico ( fuente ).

Alias ​​de tipo genérico

Antes de TypeScript 1.6, los alias de tipo estaban restringidos a ser alias simples que acortaban los nombres de tipo largo. Desafortunadamente, sin poder hacerlos genéricos, tenían un uso limitado. Ahora permitimos que los alias de tipo sean genéricos, dándoles una capacidad expresiva completa.

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

TypeScript admite importaciones, por ejemplo:

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

Actualización 1

Desde TS 1.4 podemos usar declaraciones de tipo:

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

var handler: MyHandler;

Desde TS 1.6 podemos usar declaraciones de tipos locales:

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 solución de un pobre es declarar una variable ficticia (por ejemplo t) con el tipo deseado y usar en typeof tlugar de la expresión de tipo largo:

var t: {(x: número, f: {(foo: cadena, bar: booleano): void}): void};

var f: tipo de t;
var g: tipo de t;