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


def BindLocal(handle, family):
  """ BindLocal(handle, family) -> None
  
  Bind a socket handle to an arbitrary local port.
  family should AF_INET or AF_INET6.
   """
  return None

def ConnectPipe(addr):
  """ ConnectPipe(addr) -> pipe_handle
  
  Connect to the pipe for asynchronous I/O (overlapped). """
  return None

def CreateEvent(EventAttributes, ManualReset, InitialState, Name):
  """ CreateEvent(EventAttributes, ManualReset, InitialState, Name) -> Handle
  
  Create an event.  EventAttributes must be None.
   """
  return None

def CreateIoCompletionPort(handle, port, key, concurrency):
  """ CreateIoCompletionPort(handle, port, key, concurrency) -> port
  
  Create a completion port or register a handle with a port. """
  return None

ERROR_IO_PENDING = 997
ERROR_NETNAME_DELETED = 64
ERROR_OPERATION_ABORTED = 995
ERROR_PIPE_BUSY = 231
ERROR_SEM_TIMEOUT = 121

def FormatMessage(error_code):
  """ FormatMessage(error_code) -> error_message
  
  Return error message for an error code. """
  return None

def GetQueuedCompletionStatus(port, msecs):
  """ GetQueuedCompletionStatus(port, msecs) -> (err, bytes, key, address)
  
  Get a message from completion port.  Wait for up to msecs milliseconds. """
  return (None, None, None, None)

INFINITE = 4294967295
INVALID_HANDLE_VALUE = 4294967295
NULL = 0

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

  def AcceptEx(self, listen_handle, accept_handle):
    """ AcceptEx(listen_handle, accept_handle) -> Overlapped[address_as_bytes]
    
    Start overlapped wait for client to connect """
    return None

  def ConnectEx(self, client_handle, address_as_bytes):
    """ ConnectEx(client_handle, address_as_bytes) -> Overlapped[None]
    
    Start overlapped connect.  client_handle should be unbound. """
    return None

  def ConnectNamedPipe(self, handle):
    """ ConnectNamedPipe(handle) -> Overlapped[None]
    
    Start overlapped wait for a client to connect. """
    return None

  def DisconnectEx(self, handle, flags):
    """ DisconnectEx(handle, flags) -> Overlapped[None]
    
    Start overlapped connect.  client_handle should be unbound. """
    return None

  def ReadFile(self, handle, size):
    """ ReadFile(handle, size) -> Overlapped[message]
    
    Start overlapped read """
    return None

  def ReadFileInto(self, handle, buf):
    """ ReadFileInto(handle, buf) -> Overlapped[bytes_transferred]
    
    Start overlapped receive """
    return None

  def TransmitFile(self, socket, file, offset, offset_high, count_to_write, count_per_send, flags):
    """ TransmitFile(socket, file, offset, offset_high, count_to_write, count_per_send, flags) -> Overlapped[None]
    
    Transmit file data over a connected socket. """
    return None

  def WSARecv(self, handle, size, flags):
    """ RecvFile(handle, size, flags) -> Overlapped[message]
    
    Start overlapped receive """
    return None

  def WSARecvInto(self, handle, buf, flags):
    """ WSARecvInto(handle, buf, flags) -> Overlapped[bytes_transferred]
    
    Start overlapped receive """
    return None

  def WSASend(self, handle, buf, flags):
    """ WSASend(handle, buf, flags) -> Overlapped[bytes_transferred]
    
    Start overlapped send """
    return None

  def WriteFile(self, handle, buf):
    """ WriteFile(handle, buf) -> Overlapped[bytes_transferred]
    
    Start overlapped write """
    return None

  address = property(None, None, None,
                     """ Address of overlapped structure """
                     )


  def cancel(self):
    """ cancel() -> None
    
    Cancel overlapped operation """
    return None

  error = None
  event = None

  def getresult(self, wait=False):
    """ getresult(wait=False) -> result
    
    Retrieve result of operation.  If wait is true then it blocks
    until the operation is finished.  If wait is false and the
    operation is still pending then an error is raised. """
    return None

  pending = property(None, None, None,
                     """ Whether the operation is pending """
                     )


def PostQueuedCompletionStatus(port, bytes, key, address):
  """ PostQueuedCompletionStatus(port, bytes, key, address) -> None
  
  Post a message to completion port. """
  return None

def RegisterWaitWithQueue(Object, CompletionPort, Overlapped, Timeout):
  """ RegisterWaitWithQueue(Object, CompletionPort, Overlapped, Timeout)
      -> WaitHandle
  
  Register wait for Object; when complete CompletionPort is notified.
   """
  pass

def ResetEvent(Handle):
  """ ResetEvent(Handle) -> None
  
  Reset event.
   """
  return None

SO_UPDATE_ACCEPT_CONTEXT = 28683
SO_UPDATE_CONNECT_CONTEXT = 28688

def SetEvent(Handle):
  """ SetEvent(Handle) -> None
  
  Set event.
   """
  return None

TF_REUSE_SOCKET = 2

def UnregisterWait(WaitHandle):
  """ UnregisterWait(WaitHandle) -> None
  
  Unregister wait handle.
   """
  return None

def UnregisterWaitEx(WaitHandle, Event):
  """ UnregisterWaitEx(WaitHandle, Event) -> None
  
  Unregister wait handle.
   """
  return None

__doc__ = None
__file__ = 'C:\\src\\ide\\build-files\\build-temp\\runtimes-release\\__os__\\win32\\runtime-python3.7\\DLLs\\_overlapped.pyd'
__loader__ = None
__name__ = '_overlapped'
__package__ = ''
__spec__ = None