Estoy trabajando en un simple nodejselectrón (anteriormente conocido como átomo shell) proyecto. Lo escribo usando angular 2, usando el proyecto la misma configuración de proyecto que recomiendan en la documentación para typecript:

tsc:

{
  "compilerOptions": {
    "target": "es5",
    "module": "system",
    "moduleResolution": "node",
    "sourceMap": true,
    "emitDecoratorMetadata": true,
    "experimentalDecorators": true,
    "removeComments": false,
    "noImplicitAny": false
  },
  "exclude": [
  "node_modules",
  "typings/main",
  "typings/main.d.ts"
  ]
}

Necesito ejecutar un comando, descubrí que puedo hacerlo con el nodo "child_process". No pude encontrar de todos modos para "importarlo" o "exigirlo" mientras usaba su tipo del archivo node.d.ts. He encontrado la interfaz "child_process" en el archivo node.d.ts que se adapta a mi necesidad, así es como se ve en el archivo node.d.ts:

    declare module "child_process" {
    import * as events from "events";
    import * as stream from "stream";

    export interface ChildProcess extends events.EventEmitter {
        stdin:  stream.Writable;
        stdout: stream.Readable;
        stderr: stream.Readable;
        pid: number;
        kill(signal?: string): void;
        send(message: any, sendHandle?: any): void;
        disconnect(): void;
        unref(): void;
    }

    export function spawn(command: string, args?: string[], options?: {
        cwd?: string;
        stdio?: any;
        custom?: any;
        env?: any;
        detached?: boolean;
    }): ChildProcess;
    export function exec(command: string, options: {
        cwd?: string;
        stdio?: any;
        customFds?: any;
        env?: any;
        encoding?: string;
        timeout?: number;
        maxBuffer?: number;
        killSignal?: string;
    }, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
    export function exec(command: string, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
    export function execFile(file: string,
        callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
    export function execFile(file: string, args?: string[],
        callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
    export function execFile(file: string, args?: string[], options?: {
        cwd?: string;
        stdio?: any;
        customFds?: any;
        env?: any;
        encoding?: string;
        timeout?: number;
        maxBuffer?: number;
        killSignal?: string;
    }, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
    export function fork(modulePath: string, args?: string[], options?: {
        cwd?: string;
        env?: any;
        execPath?: string;
        execArgv?: string[];
        silent?: boolean;
        uid?: number;
        gid?: number;
    }): ChildProcess;
    export function spawnSync(command: string, args?: string[], options?: {
        cwd?: string;
        input?: string | Buffer;
        stdio?: any;
        env?: any;
        uid?: number;
        gid?: number;
        timeout?: number;
        maxBuffer?: number;
        killSignal?: string;
        encoding?: string;
    }): {
        pid: number;
        output: string[];
        stdout: string | Buffer;
        stderr: string | Buffer;
        status: number;
        signal: string;
        error: Error;
    };
    export function execSync(command: string, options?: {
        cwd?: string;
        input?: string|Buffer;
        stdio?: any;
        env?: any;
        uid?: number;
        gid?: number;
        timeout?: number;
        maxBuffer?: number;
        killSignal?: string;
        encoding?: string;
    }): string | Buffer;
    export function execFileSync(command: string, args?: string[], options?: {
        cwd?: string;
        input?: string|Buffer;
        stdio?: any;
        env?: any;
        uid?: number;
        gid?: number;
        timeout?: number;
        maxBuffer?: number;
        killSignal?: string;
        encoding?: string;
    }): string | Buffer;
}

pero solo puedo (como sé) obtener este tipo solo usando import:

import * as child_process from 'child_process'; 

El único problema es que cuando hago esto, mi aplicación no se puede cargar y aparece el siguiente error en la consola:

GET file:///C:/angular2Samples/NGW-electron-VS%20-%20TEMP/child_process net::ERR_FILE_NOT_FOUND

Por ahora, me estoy moviendo usando:

var child_process = require('child_process');

pero no pude encontrar de todos modos para agregar la información de tipo a esta var:

var child_process : I_CANT_PUT_ANY_CHILD_PROCESS_TYPE_HERE = require('child_process');

¿Alguna idea sobre cómo puedo obtener el child_process (o cualquier otro módulo de nodo declarado que no sea una interfaz pública que pueda indicar después del operador ":") con información de tipo?

Muchas gracias de antemano por cualquier ayuda y explicaciones :)

ACTUALIZACIÓN ------------------------------------------------- -----------------

Como sugirieron los tenbits, he agregado la referencia de la siguiente manera al principio del archivo: ///

y utilicé la declaración de importación que dijiste, pero no cambié mi cargador de módulos. todavía no funcionó con el mismo error que se esperaba. No me siento muy cómodo al cambiar el sistema de módulos, ya que mi proyecto usa angular 2 y sus documentos y algunas de sus guías dijeron que los nuevos proyectos que no tienen preferencia previa a este asunto (soy muy nuevo en la escena de cargadores de módulos y no soy comprender completamente cómo funciona todavía). Cuando intenté cambiarlo, obtuve algunos errores con respecto a las cosas angulares 2 que no tengo tiempo suficiente para abordar en este momento. ¿No debería haber una forma de hacerlo sin cambiar el cargador de módulos? Al echar un vistazo al sitio systemjs, dice al principio que admite módulos commonjs:Systemjs doc

Realmente recomendaría una solución que no cambie el sistema de módulos, o tal vez exista una explicación más profunda sobre lo que está sucediendo y los enfoques para este tipo de problemas de carga de módulos.