# coding: utf-8
# AUTO-GENERATED FILE -- DO NOT EDIT


CREATE_NEW_CONSOLE = 16
CREATE_NEW_PROCESS_GROUP = 512

def CloseHandle(handle):
  """ CloseHandle(handle) -> None
  
  Close handle. """
  return None

def ConnectNamedPipe():
  """  """
  pass

def CreateFile():
  """  """
  pass

def CreateNamedPipe():
  """  """
  pass

def CreatePipe(pipe_attrs, size):
  """ CreatePipe(pipe_attrs, size) -> (read_handle, write_handle)
  
  Create an anonymous pipe, and return handles to the read and
  write ends of the pipe.
  
  pipe_attrs is ignored internally and can be None. """
  return (None, None)

def CreateProcess(app_name, cmd_line, proc_attrs, thread_attrs, inherit, flags, env_mapping, curdir, startup_info):
  """ CreateProcess(app_name, cmd_line, proc_attrs, thread_attrs,
                 inherit, flags, env_mapping, curdir,
                 startup_info) -> (proc_handle, thread_handle,
                                   pid, tid)
  
  Create a new process and its primary thread. The return
  value is a tuple of the process handle, thread handle,
  process ID, and thread ID.
  
  proc_attrs and thread_attrs are ignored internally and can be None. """
  return (None, None, None, None)

DUPLICATE_CLOSE_SOURCE = 1
DUPLICATE_SAME_ACCESS = 2

def DuplicateHandle(source_proc_handle, source_handle, target_proc_handle, target_handle, access, inherit, options=None):
  """ DuplicateHandle(source_proc_handle, source_handle,
                   target_proc_handle, target_handle, access,
                   inherit[, options]) -> handle
  
  Return a duplicate handle object.
  
  The duplicate handle refers to the same object as the original
  handle. Therefore, any changes to the object are reflected
  through both handles. """
  return None

ERROR_ALREADY_EXISTS = 183
ERROR_BROKEN_PIPE = 109
ERROR_IO_PENDING = 997
ERROR_MORE_DATA = 234
ERROR_NETNAME_DELETED = 64
ERROR_NO_DATA = 232
ERROR_NO_SYSTEM_RESOURCES = 1450
ERROR_OPERATION_ABORTED = 995
ERROR_PIPE_BUSY = 231
ERROR_PIPE_CONNECTED = 535
ERROR_SEM_TIMEOUT = 121

def ExitProcess():
  """  """
  pass

FILE_FLAG_FIRST_PIPE_INSTANCE = 524288
FILE_FLAG_OVERLAPPED = 1073741824
FILE_GENERIC_READ = 1179785
FILE_GENERIC_WRITE = 1179926
GENERIC_READ = 2147483648
GENERIC_WRITE = 1073741824

def GetCurrentProcess():
  """ GetCurrentProcess() -> handle
  
  Return a handle object for the current process. """
  return None

def GetExitCodeProcess(handle):
  """ GetExitCodeProcess(handle) -> Exit code
  
  Return the termination status of the specified process. """
  return None

def GetLastError():
  """ GetCurrentProcess() -> handle
  
  Return a handle object for the current process. """
  return None

def GetModuleFileName(module):
  """ GetModuleFileName(module) -> path
  
  Return the fully-qualified path for the file that contains
  the specified module. The module must have been loaded by the
  current process.
  
  The module parameter should be a handle to the loaded module
  whose path is being requested. If this parameter is 0, 
  GetModuleFileName retrieves the path of the executable file
  of the current process. """
  return None

def GetStdHandle(handle):
  """ GetStdHandle(handle) -> integer
  
  Return a handle to the specified standard device
  (STD_INPUT_HANDLE, STD_OUTPUT_HANDLE, STD_ERROR_HANDLE).
  The integer associated with the handle object is returned. """
  return 1

def GetVersion():
  """ GetVersion() -> version
  
  Return the version number of the current operating system. """
  return None

INFINITE = 4294967295
NMPWAIT_WAIT_FOREVER = 4294967295
NULL = 0
OPEN_EXISTING = 3

def OpenProcess():
  """  """
  pass

class Overlapped(object):
  """ OVERLAPPED structure wrapper """

  def GetOverlappedResult(self):
    pass

  def cancel(self):
    pass

  event = None

  def getbuffer(self):
    pass

PIPE_ACCESS_DUPLEX = 3
PIPE_ACCESS_INBOUND = 1
PIPE_READMODE_MESSAGE = 2
PIPE_TYPE_MESSAGE = 4
PIPE_UNLIMITED_INSTANCES = 255
PIPE_WAIT = 0
PROCESS_ALL_ACCESS = 2035711
PROCESS_DUP_HANDLE = 64

def PeekNamedPipe():
  """  """
  pass

def ReadFile():
  """  """
  pass

STARTF_USESHOWWINDOW = 1
STARTF_USESTDHANDLES = 256
STD_ERROR_HANDLE = 4294967284
STD_INPUT_HANDLE = 4294967286
STD_OUTPUT_HANDLE = 4294967285
STILL_ACTIVE = 259
SW_HIDE = 0

def SetNamedPipeHandleState():
  """  """
  pass

def TerminateProcess(handle, exit_code):
  """ TerminateProcess(handle, exit_code) -> None
  
  Terminate the specified process and all of its threads. """
  return None

WAIT_OBJECT_0 = 0
WAIT_TIMEOUT = 258

def WaitForMultipleObjects():
  """  """
  pass

def WaitForSingleObject(handle, timeout):
  """ WaitForSingleObject(handle, timeout) -> result
  
  Wait until the specified object is in the signaled state or
  the time-out interval elapses. The timeout value is specified
  in milliseconds. """
  return None

def WaitNamedPipe():
  """  """
  pass

def WriteFile():
  """  """
  pass

__doc__ = None

class __loader__(object):
  """ Meta path import for built-in modules.
  
      All methods are either class or static methods to avoid the need to
      instantiate the class.
  
       """

  def find_module(self, fullname, path=None):
    """ Find the built-in module.
    
            If 'path' is ever specified then the search is considered a failure.
    
            This method is deprecated.  Use find_spec() instead.
    
             """
    pass

  def find_spec(self, fullname, path=None, target=None):
    pass

  def get_code(self, fullname):
    """ Return None as built-in modules do not have code objects. """
    pass

  def get_source(self, fullname):
    """ Return None as built-in modules do not have source code. """
    pass

  def is_package(self, fullname):
    """ Return False as built-in modules are never packages. """
    pass

  def load_module(self, fullname):
    """ Load a built-in module. """
    pass

  def module_repr(self, module):
    """ Return repr for the module.
    
            The method is deprecated.  The import machinery does the job itself.
    
             """
    pass

__name__ = '_winapi'
__package__ = ''
__spec__ = None