Estou trabalhando em um nodejs simpleselétron (anteriormente conhecido como atom shell). Estou escrevendo usando angular 2, usando o projeto com a mesma configuração de projeto que eles recomendam na documentação para texto datilografado:

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"
  ]
}

Eu preciso executar um comando, descobri que posso fazê-lo com o nó "child_process". Não consegui encontrar nenhuma maneira de "importá-lo" ou "exigi-lo" enquanto meu tipo era usado no arquivo node.d.ts. Eu encontrei a interface "child_process" no arquivo node.d.ts que se adapta às minhas necessidades, é assim que está no arquivo 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;
}

mas só posso (como eu sei) obter esse tipo apenas usando import:

import * as child_process from 'child_process'; 

O único problema é que, quando faço isso, meu aplicativo não pode ser carregado e recebo o seguinte erro no console:

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

Por enquanto, estou conseguindo contornar usando:

var child_process = require('child_process');

mas não consegui encontrar nenhuma maneira de adicionar as informações de tipo a essa var:

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

Alguma idéia de como eu posso obter o child_process (ou qualquer outro módulo de nó declarado que não seja interface pública que eu possa indicar após o operador ":") com informações de tipo?

Agradecemos antecipadamente por qualquer ajuda e explicações :)

ATUALIZAÇÃO ------------------------------------------------- -----------------

Como sugerido por dez bits, adicionei a referência a seguir no topo do arquivo: ///

e usei a declaração de importação que você disse, mas não alterou meu carregador de módulos. ainda não funcionou com o mesmo erro que o esperado. Não estou me sentindo muito confortável em mudar o sistema de módulos, pois meu projeto usa o angular 2 e seus documentos e alguns de seus guias disseram que novos projetos que não têm preferência anterior a esse assunto (eu sou muito novo na cena dos carregadores de módulos e não sou entender completamente como funciona ainda). Quando tentei alterá-lo, obtive alguns erros em relação aos materiais angulares 2 que não tenho tempo suficiente para entrar no momento. Não deveria haver uma maneira de fazer isso sem alterar o carregador de módulos? olhando para o site systemjs, ele diz no início que suporta os módulos commonjs:Doc do Systemjs

Eu realmente aprovaria uma solução que não altera o sistema do módulo, ou talvez exista uma explicação mais aprofundada sobre o que está acontecendo e quais abordagens para esse tipo de problema de carregamento do módulo