/**@class java.lang.Process
@extends java.lang.Object

 Represents an external process. Enables writing to, reading from, destroying,
 and waiting for the external process, as well as querying its exit value. Use
 {@link java.lang.ProcessBuilder} to create processes.

 <p>The child process writes its output to two streams, {@code out} and
 {@code err}. These streams should be read by the parent process using {@link #getInputStream}() and {@link #getErrorStream}() respectively. If these
 streams are not read, the target process may block while it awaits buffer
 space. It isn't sufficient to read the streams in sequence; to avoid blocking
 each of the two streams must have its own reader thread. If you are not
 interested in differentiating the out and err streams, use {@link java.lang.ProcessBuilder#redirectErrorStream(boolean) redirectErrorStream(true)} to
 merge the two streams. This simplifies your reading code and makes it easier
 to avoid blocking the target process.

 <p>Running processes hold resources. When a process is no longer used, the
 process should be closed by calling {@link #destroy}. This will kill the
 process and release the resources that it holds.

 <p>For example, to run {@code /system/bin/ping} to ping {@code android.com}:
 <pre>   {@code
   Process process = new ProcessBuilder()
       .command("/system/bin/ping", "android.com")
       .redirectErrorStream(true)
       .start();
   try {
     InputStream in = process.getInputStream();
     OutputStream out = process.getOutputStream();

     readStream(in);

   } finally {
     process.destroy();
   }
 }</pre>
*/
var Process = {

/**Terminates this process and closes any associated streams.
*/
destroy : function(  ) {},

/**Returns the exit value of the native process represented by this object.
 It is available only when the native process has terminated.
@return {Number} the exit value of this process.
@throws IllegalThreadStateException
             if this process has not terminated.
*/
exitValue : function(  ) {},

/**Returns an input stream that is connected to the error stream
 <em>(stderr)</em> of the native process represented by this object.
@return {Object {java.io.InputStream}} the input stream to read from the error stream associated with
         the native process.
*/
getErrorStream : function(  ) {},

/**Returns an input stream that is connected to the standard output stream
 <em>(stdout)</em> of the native process represented by this object.
@return {Object {java.io.InputStream}} the input stream to read from the output stream associated with
         the native process.
*/
getInputStream : function(  ) {},

/**Returns an output stream that is connected to the standard input stream
 <em>(stdin)</em> of the native process represented by this object.
@return {Object {java.io.OutputStream}} the output stream to write to the input stream associated with
         the native process.
*/
getOutputStream : function(  ) {},

/**Causes the calling thread to wait for the native process associated with
 this object to finish executing.
@return {Number} the exit value of the native process being waited on.
@throws InterruptedException
             if the calling thread is interrupted.
*/
waitFor : function(  ) {},


};