Interfaz importada de exportación de TypeScript

Utilizo módulos AMD y quiero ocultar una interfaz compleja detrás de un archivo que carga varios otros archivos y elige qué exponer y cómo. Funciona, uso esta solución pero se siente un poco feo, principalmente con las interfaces.

import Types = require('./message-types');
import MessageBaseImport = require('./message-base');
export interface IMessage extends Types.IMessage {} // This is an interface
export var MessageBase = MessageBaseImport; // This is a class

Uso:

import Message = require('message');
import { * } as Message from 'message'; // Or with ES6 style
var mb = new Message.MessageBase(); // Using the class
var msg: Message.IMessage = null; // Using the interface 

¿Alguna mejor solución por ahí? No quiero poner todo en un solo archivo, pero quiero importun solo archivo.

Existe una sintaxis de importación de exportación para módulos heredados y un formato de exportación estándar para módulos ES6 modernos:

// export the default export of a legacy (`export =`) module
export import MessageBase = require('./message-base');

// export the default export of a modern (`export default`) module
export { default as MessageBase } from './message-base';

// when '--isolatedModules' flag is provided it requires using 'export type'.
export type { default as MessageBase } from './message-base';

// export an interface from a legacy module
import Types = require('./message-types');
export type IMessage = Types.IMessage;

// export an interface from a modern module
export { IMessage } from './message-types';

Algunos ejemplos más además de la respuesta de # c-snover de aquí . Puedes juntarlos.

import 'jquery';                        // import a module without any import bindings
import $ from 'jquery';                 // import the default export of a module
import { $ } from 'jquery';             // import a named export of a module
import { $ as jQuery } from 'jquery';   // import a named export to a different name
import * as crypto from 'crypto';       // import an entire module instance object

export var x = 42;                      // export a named variable
export function foo() {};               // export a named function

export default 42;                      // export the default export
export default function foo() {};       // export the default export as a function

export { encrypt };                     // export an existing variable
export { decrypt as dec };              // export a variable as a new name
export { encrypt as en } from 'crypto'; // export an export from another module
export * from 'crypto';                 // export all exports from another module
                                        // (except the default export)

En mi caso particularmente, tuve que 'declarar' la interfaz en lugar de exportarla.

declare interface IFluxStoreSyncOptions{
  namespacedKey: string;
}

Para usar la interfaz como un tipo en otro archivo como este:

export function FluxStoreSync(options: IFluxStoreSyncOptions){
}

De esta manera, no tiene que exportar e importar la interfaz.