Module libuv

libuv is still fast moving target This file was last updated against a development HEAD revision of https://github.com/joyent/libuv/Use the following link to see changes (in uv.h) since then and don't forget to update the information here. https://github.com/joyent/libuv/compare/9f6024a6fa9d254527b4b59af724257df870288b...master

Types

TPort = distinct int16
port type   Source
cssize = int
  Source
coff = int
  Source
csize = int
  Source
AllocProc = proc (handle: PHandle; suggested_size: csize): TBuf {.cdecl.}
  Source
ReadProc = proc (stream: PStream; nread: cssize; buf: TBuf) {.cdecl.}
  Source
ReadProc2 = proc (stream: PPipe; nread: cssize; buf: TBuf; pending: THandleType) {.
    cdecl.}
  Source
WriteProc = proc (req: PWrite; status: cint) {.cdecl.}
  Source
ConnectProc = proc (req: PConnect; status: cint) {.cdecl.}
  Source
ShutdownProc = proc (req: PShutdown; status: cint) {.cdecl.}
  Source
ConnectionProc = proc (server: PStream; status: cint) {.cdecl.}
  Source
CloseProc = proc (handle: PHandle) {.cdecl.}
  Source
TimerProc = proc (handle: PTimer; status: cint) {.cdecl.}
  Source
AsyncProc = proc (handle: PAsync; status: cint) {.cdecl.}
  Source
PrepareProc = proc (handle: PPrepare; status: cint) {.cdecl.}
  Source
CheckProc = proc (handle: PCheck; status: cint) {.cdecl.}
  Source
IdleProc = proc (handle: PIdle; status: cint) {.cdecl.}
  Source
PSockAddr = ptr SockAddr
  Source
GetAddrInfoProc = proc (handle: PGetAddrInfo; status: cint; res: ptr AddrInfo)
  Source
ExitProc = proc (a2: PProcess; exit_status: cint; term_signal: cint)
  Source
FsProc = proc (req: PFS)
  Source
WorkProc = proc (req: PWork)
  Source
AfterWorkProc = proc (req: PWork)
  Source
FsEventProc = proc (handle: PFsEvent; filename: cstring; events: cint; 
                    status: cint)
  Source
TErrorCode = enum 
  UNKNOWN = - 1, OK = 0, EOF, EACCESS, EAGAIN, EADDRINUSE, EADDRNOTAVAIL, 
  EAFNOSUPPORT, EALREADY, EBADF, EBUSY, ECONNABORTED, ECONNREFUSED, ECONNRESET, 
  EDESTADDRREQ, EFAULT, EHOSTUNREACH, EINTR, EINVAL, EISCONN, EMFILE, EMSGSIZE, 
  ENETDOWN, ENETUNREACH, ENFILE, ENOBUFS, ENOMEM, ENONET, ENOPROTOOPT, ENOTCONN, 
  ENOTSOCK, ENOTSUP, ENOENT, EPIPE, EPROTO, EPROTONOSUPPORT, EPROTOTYPE, 
  ETIMEDOUT, ECHARSET, EAIFAMNOSUPPORT, EAINONAME, EAISERVICE, EAISOCKTYPE, 
  ESHUTDOWN, EEXIST
  Source
THandleType = enum 
  UNKNOWN_HANDLE = 0, TCP, UDP, NAMED_PIPE, TTY, FILE, TIMER, PREPARE, CHECK, 
  IDLE, ASYNC, ARES_TASK, ARES_EVENT, PROCESS, FS_EVENT
  Source
TReqType = enum 
  rUNKNOWN_REQ = 0, rCONNECT, rACCEPT, rREAD, rWRITE, rSHUTDOWN, rWAKEUP, 
  rUDP_SEND, rFS, rWORK, rGETADDRINFO, rREQ_TYPE_PRIVATE
  Source
TErr = object 
  code* {.importc: "code".}: TErrorCode
  sys_errno* {.importc: "sys_errno_".}: cint
  Source
TFsEventType = enum 
  evRENAME = 1, evCHANGE = 2
  Source
TFsEvent = object 
  loop* {.importc: "loop".}: PLoop
  typ* {.importc: "type".}: THandleType
  close_cb* {.importc: "close_cb".}: CloseProc
  data* {.importc: "data".}: pointer
  filename {.importc: "filename".}: cstring
  Source
PFsEvent = ptr TFsEvent
  Source
TFsEvents = object 
  loop* {.importc: "loop".}: PLoop
  typ* {.importc: "type".}: THandleType
  close_cb* {.importc: "close_cb".}: CloseProc
  data* {.importc: "data".}: pointer
  filename* {.importc: "filename".}: cstring
  Source
TBuf = object 
  base* {.importc: "base".}: cstring
  len* {.importc: "len".}: csize
  Source
TAnyHandle = object 
  tcp* {.importc: "tcp".}: TTcp
  pipe* {.importc: "pipe".}: TPipe
  prepare* {.importc: "prepare".}: TPrepare
  check* {.importc: "check".}: TCheck
  idle* {.importc: "idle".}: TIdle
  async* {.importc: "async".}: TAsync
  timer* {.importc: "timer".}: TTimer
  getaddrinfo* {.importc: "getaddrinfo".}: TGetAddrInfo
  fs_event* {.importc: "fs_event".}: TFsEvents
  Source
TAnyReq = object 
  req* {.importc: "req".}: TReq
  write* {.importc: "write".}: TWrite
  connect* {.importc: "connect".}: TConnect
  shutdown* {.importc: "shutdown".}: TShutdown
  fs_req* {.importc: "fs_req".}: TFS
  work_req* {.importc: "work_req".}: TWork
  Source
uint64 = int64
  Source
TCounters = object 
  eio_init* {.importc: "eio_init".}: uint64
  req_init* {.importc: "req_init".}: uint64
  handle_init* {.importc: "handle_init".}: uint64
  stream_init* {.importc: "stream_init".}: uint64
  tcp_init* {.importc: "tcp_init".}: uint64
  udp_init* {.importc: "udp_init".}: uint64
  pipe_init* {.importc: "pipe_init".}: uint64
  tty_init* {.importc: "tty_init".}: uint64
  prepare_init* {.importc: "prepare_init".}: uint64
  check_init* {.importc: "check_init".}: uint64
  idle_init* {.importc: "idle_init".}: uint64
  async_init* {.importc: "async_init".}: uint64
  timer_init* {.importc: "timer_init".}: uint64
  process_init* {.importc: "process_init".}: uint64
  fs_event_init* {.importc: "fs_event_init".}: uint64
  Source
TLoop = object 
  eio_want_poll_notifier* {.importc: "uv_eio_want_poll_notifier".}: TAsync
  eio_done_poll_notifier* {.importc: "uv_eio_done_poll_notifier".}: TAsync
  eio_poller* {.importc: "uv_eio_poller".}: TIdle
  counters* {.importc: "counters".}: TCounters
  last_err* {.importc: "last_err".}: TErr
  data* {.importc: "data".}: pointer
  Source
PLoop = ptr TLoop
  Source
TShutdown = object 
  typ* {.importc: "type".}: TReqType
  data* {.importc: "data".}: pointer
  handle* {.importc: "handle".}: PStream
  cb* {.importc: "cb".}: ShutdownProc
  Source
PShutdown = ptr TShutdown
  Source
THandle = object 
  loop* {.importc: "loop".}: PLoop
  typ* {.importc: "type".}: THandleType
  close_cb* {.importc: "close_cb".}: CloseProc
  data* {.importc: "data".}: pointer
  Source
PHandle = ptr THandle
  Source
TStream = object 
  loop* {.importc: "loop".}: PLoop
  typ* {.importc: "type".}: THandleType
  alloc_cb* {.importc: "alloc_cb".}: AllocProc
  read_cb* {.importc: "read_cb".}: ReadProc
  read2_cb* {.importc: "read2_cb".}: ReadProc2
  close_cb* {.importc: "close_cb".}: CloseProc
  data* {.importc: "data".}: pointer
  write_queue_size* {.importc: "write_queue_size".}: csize
  Source
PStream = ptr TStream
  Source
TWrite = object 
  typ* {.importc: "type".}: TReqType
  data* {.importc: "data".}: pointer
  cb* {.importc: "cb".}: WriteProc
  send_handle* {.importc: "send_handle".}: PStream
  handle* {.importc: "handle".}: PStream
  Source
PWrite = ptr TWrite
  Source
TTcp = object 
  loop* {.importc: "loop".}: PLoop
  typ* {.importc: "type".}: THandleType
  alloc_cb* {.importc: "alloc_cb".}: AllocProc
  read_cb* {.importc: "read_cb".}: ReadProc
  read2_cb* {.importc: "read2_cb".}: ReadProc2
  close_cb* {.importc: "close_cb".}: CloseProc
  data* {.importc: "data".}: pointer
  write_queue_size* {.importc: "write_queue_size".}: csize
  Source
PTcp = ptr TTcp
  Source
TConnect = object 
  typ* {.importc: "type".}: TReqType
  data* {.importc: "data".}: pointer
  cb* {.importc: "cb".}: ConnectProc
  handle* {.importc: "handle".}: PStream
  Source
PConnect = ptr TConnect
  Source
TUdpFlags = enum 
  UDP_IPV6ONLY = 1, UDP_PARTIAL = 2
  Source
cunsigned = int
  Source
UdpSendProc = proc (req: PUdpSend; status: cint)
  Source
UdpRecvProc = proc (handle: PUdp; nread: cssize; buf: TBuf; adr: ptr SockAddr; 
                    flags: cunsigned)
  Source
TUdp = object 
  loop* {.importc: "loop".}: PLoop
  typ* {.importc: "type".}: THandleType
  close_cb* {.importc: "close_cb".}: CloseProc
  data* {.importc: "data".}: pointer
  Source
PUdp = ptr TUdp
  Source
TUdpSend = object 
  typ* {.importc: "type".}: TReqType
  data* {.importc: "data".}: pointer
  handle* {.importc: "handle".}: PUdp
  cb* {.importc: "cb".}: UdpSendProc
  Source
PUdpSend = ptr TUdpSend
  Source
tTTy = object 
  loop* {.importc: "loop".}: PLoop
  typ* {.importc: "type".}: THandleType
  alloc_cb* {.importc: "alloc_cb".}: AllocProc
  read_cb* {.importc: "read_cb".}: ReadProc
  read2_cb* {.importc: "read2_cb".}: ReadProc2
  close_cb* {.importc: "close_cb".}: CloseProc
  data* {.importc: "data".}: pointer
  write_queue_size* {.importc: "write_queue_size".}: csize
  Source
pTTy = ptr tTTy
  Source
TPipe = object 
  loop* {.importc: "loop".}: PLoop
  typ* {.importc: "type".}: THandleType
  alloc_cb* {.importc: "alloc_cb".}: AllocProc
  read_cb* {.importc: "read_cb".}: ReadProc
  read2_cb* {.importc: "read2_cb".}: ReadProc2
  close_cb* {.importc: "close_cb".}: CloseProc
  data* {.importc: "data".}: pointer
  write_queue_size* {.importc: "write_queue_size".}: csize
  ipc {.importc: "ipc".}: int
  Source
PPipe = ptr TPipe
  Source
TPrepare = object 
  loop* {.importc: "loop".}: PLoop
  typ* {.importc: "type".}: THandleType
  close_cb* {.importc: "close_cb".}: CloseProc
  data* {.importc: "data".}: pointer
  Source
PPrepare = ptr TPrepare
  Source
TCheck = object 
  loop* {.importc: "loop".}: PLoop
  typ* {.importc: "type".}: THandleType
  close_cb* {.importc: "close_cb".}: CloseProc
  data* {.importc: "data".}: pointer
  Source
PCheck = ptr TCheck
  Source
TIdle = object 
  loop* {.importc: "loop".}: PLoop
  typ* {.importc: "type".}: THandleType
  close_cb* {.importc: "close_cb".}: CloseProc
  data* {.importc: "data".}: pointer
  Source
PIdle = ptr TIdle
  Source
TAsync = object 
  loop* {.importc: "loop".}: PLoop
  typ* {.importc: "type".}: THandleType
  close_cb* {.importc: "close_cb".}: CloseProc
  data* {.importc: "data".}: pointer
  Source
PAsync = ptr TAsync
  Source
TTimer = object 
  loop* {.importc: "loop".}: PLoop
  typ* {.importc: "type".}: THandleType
  close_cb* {.importc: "close_cb".}: CloseProc
  data* {.importc: "data".}: pointer
  Source
PTimer = ptr TTimer
  Source
TGetAddrInfo = object 
  typ* {.importc: "type".}: TReqType
  data* {.importc: "data".}: pointer
  loop* {.importc: "loop".}: PLoop
  Source
PGetAddrInfo = ptr TGetAddrInfo
  Source
TProcessOptions = object 
  exit_cb* {.importc: "exit_cb".}: ExitProc
  file* {.importc: "file".}: cstring
  args* {.importc: "args".}: cstringArray
  env* {.importc: "env".}: cstringArray
  cwd* {.importc: "cwd".}: cstring
  windows_verbatim_arguments* {.importc: "windows_verbatim_arguments".}: cint
  stdin_stream* {.importc: "stdin_stream".}: PPipe
  stdout_stream* {.importc: "stdout_stream".}: PPipe
  stderr_stream* {.importc: "stderr_stream".}: PPipe
  Source
PProcessOptions = ptr TProcessOptions
  Source
TProcess = object 
  loop* {.importc: "loop".}: PLoop
  typ* {.importc: "type".}: THandleType
  close_cb* {.importc: "close_cb".}: CloseProc
  data* {.importc: "data".}: pointer
  exit_cb* {.importc: "exit_cb".}: ExitProc
  pid* {.importc: "pid".}: cint
  Source
PProcess = ptr TProcess
  Source
TWork = object 
  typ* {.importc: "type".}: TReqType
  data* {.importc: "data".}: pointer
  loop* {.importc: "loop".}: PLoop
  work_cb* {.importc: "work_cb".}: WorkProc
  after_work_cb* {.importc: "after_work_cb".}: AfterWorkProc
  Source
PWork = ptr TWork
  Source
TFsType = enum 
  FS_UNKNOWN = - 1, FS_CUSTOM, FS_OPEN, FS_CLOSE, FS_READ, FS_WRITE, 
  FS_SENDFILE, FS_STAT, FS_LSTAT, FS_FSTAT, FS_FTRUNCATE, FS_UTIME, FS_FUTIME, 
  FS_CHMOD, FS_FCHMOD, FS_FSYNC, FS_FDATASYNC, FS_UNLINK, FS_RMDIR, FS_MKDIR, 
  FS_RENAME, FS_READDIR, FS_LINK, FS_SYMLINK, FS_READLINK, FS_CHOWN, FS_FCHOWN
  Source
TFS = object 
  typ* {.importc: "type".}: TReqType
  data* {.importc: "data".}: pointer
  loop* {.importc: "loop".}: PLoop
  fs_type* {.importc: "fs_type".}: TFsType
  cb* {.importc: "cb".}: FsProc
  result* {.importc: "result".}: cssize
  fsPtr* {.importc: "ptr".}: pointer
  path* {.importc: "path".}: cstring
  errorno* {.importc: "errorno".}: cint
  Source
PFS = ptr TFS
  Source
TReq = object 
  typ* {.importc: "type".}: TReqType
  data* {.importc: "data".}: pointer
  Source
PReq = ptr TReq
  Source
TAresOptions = object 
  flags* {.importc: "flags".}: int
  timeout* {.importc: "timeout".}: int
  tries* {.importc: "tries".}: int
  ndots* {.importc: "ndots".}: int
  udp_port* {.importc: "udp_port".}: TPort
  tcp_port* {.importc: "tcp_port".}: TPort
  socket_send_buffer_size* {.importc: "socket_send_buffer_size".}: int
  socket_recv_buffer_size* {.importc: "socket_receive_buffer_size".}: int
  servers* {.importc: "servers".}: ptr InAddr
  nservers* {.importc: "nservers".}: int
  domains* {.importc: "domains".}: ptr cstring
  ndomains* {.importc: "ndomains".}: int
  lookups* {.importc: "lookups".}: cstring
  Source
PAresOptions = ptr TAresOptions
  Source
PAresChannel = pointer
  Source

Procs

proc loop_new(): PLoop {.importc: "uv_loop_new", header: "uv.h".}
  Source
proc loop_delete(a2: PLoop) {.importc: "uv_loop_delete", header: "uv.h".}
  Source
proc default_loop(): PLoop {.importc: "uv_default_loop", header: "uv.h".}
  Source
proc run(a2: PLoop): cint {.importc: "uv_run", header: "uv.h".}
  Source
proc addref(a2: PLoop) {.importc: "uv_ref", header: "uv.h".}
  Source
proc unref(a2: PLoop) {.importc: "uv_unref", header: "uv.h".}
  Source
proc update_time(a2: PLoop) {.importc: "uv_update_time", header: "uv.h".}
  Source
proc now(a2: PLoop): int64 {.importc: "uv_now", header: "uv.h".}
  Source
proc last_error(a2: PLoop): TErr {.importc: "uv_last_error", header: "uv.h".}
  Source
proc strerror(err: TErr): cstring {.importc: "uv_strerror", header: "uv.h".}
  Source
proc err_name(err: TErr): cstring {.importc: "uv_err_name", header: "uv.h".}
  Source
proc shutdown(req: PShutdown; handle: PStream; cb: ShutdownProc): cint {.
    importc: "uv_shutdown", header: "uv.h".}
  Source
proc is_active(handle: PHandle): cint {.importc: "uv_is_active", header: "uv.h".}
  Source
proc close(handle: PHandle; close_cb: CloseProc) {.importc: "uv_close", 
    header: "uv.h".}
  Source
proc buf_init(base: cstring; len: csize): TBuf {.importc: "uv_buf_init", 
    header: "uv.h".}
  Source
proc listen(stream: PStream; backlog: cint; cb: ConnectionProc): cint {.
    importc: "uv_listen", header: "uv.h".}
  Source
proc accept(server: PStream; client: PStream): cint {.importc: "uv_accept", 
    header: "uv.h".}
  Source
proc read_start(a2: PStream; alloc_cb: AllocProc; read_cb: ReadProc): cint {.
    importc: "uv_read_start", header: "uv.h".}
  Source
proc read_start(a2: PStream; alloc_cb: AllocProc; read_cb: ReadProc2): cint {.
    importc: "uv_read2_start", header: "uv.h".}
  Source
proc read_stop(a2: PStream): cint {.importc: "uv_read_stop", header: "uv.h".}
  Source
proc write(req: PWrite; handle: PStream; bufs: ptr TBuf; bufcnt: cint; 
           cb: WriteProc): cint {.importc: "uv_write", header: "uv.h".}
  Source
proc write(req: PWrite; handle: PStream; bufs: ptr TBuf; bufcnt: cint; 
           send_handle: PStream; cb: WriteProc): cint {.importc: "uv_write2", 
    header: "uv.h".}
  Source
proc tcp_init(a2: PLoop; handle: PTcp): cint {.importc: "uv_tcp_init", 
    header: "uv.h".}
  Source
proc tcp_bind(handle: PTcp; a3: Sockaddr_in): cint {.importc: "uv_tcp_bind", 
    header: "uv.h".}
  Source
proc tcp_bind6(handle: PTcp; a3: Tsockaddr_in6): cint {.importc: "uv_tcp_bind6", 
    header: "uv.h".}
  Source
proc tcp_getsockname(handle: PTcp; name: ptr SockAddr; namelen: var cint): cint {.
    importc: "uv_tcp_getsockname", header: "uv.h".}
  Source
proc tcp_getpeername(handle: PTcp; name: ptr SockAddr; namelen: var cint): cint {.
    importc: "uv_tcp_getpeername", header: "uv.h".}
  Source
proc tcp_connect(req: PConnect; handle: PTcp; address: Sockaddr_in; 
                 cb: ConnectProc): cint {.importc: "uv_tcp_connect", 
    header: "uv.h".}
  Source
proc tcp_connect6(req: PConnect; handle: PTcp; address: Tsockaddr_in6; 
                  cb: ConnectProc): cint {.importc: "uv_tcp_connect6", 
    header: "uv.h".}
  Source
proc udp_init(a2: PLoop; handle: PUdp): cint {.importc: "uv_udp_init", 
    header: "uv.h".}
  Source
proc udp_bind(handle: PUdp; adr: Sockaddr_in; flags: cunsigned): cint {.
    importc: "uv_udp_bind", header: "uv.h".}
  Source
proc udp_bind6(handle: PUdp; adr: Tsockaddr_in6; flags: cunsigned): cint {.
    importc: "uv_udp_bind6", header: "uv.h".}
  Source
proc udp_getsockname(handle: PUdp; name: ptr SockAddr; namelen: var cint): cint {.
    importc: "uv_udp_getsockname", header: "uv.h".}
  Source
proc udp_send(req: PUdpSend; handle: PUdp; bufs: ptr TBuf; bufcnt: cint; 
              adr: Sockaddr_in; send_cb: UdpSendProc): cint {.
    importc: "uv_udp_send", header: "uv.h".}
  Source
proc udp_send6(req: PUdpSend; handle: PUdp; bufs: ptr TBuf; bufcnt: cint; 
               adr: Tsockaddr_in6; send_cb: UdpSendProc): cint {.
    importc: "uv_udp_send6", header: "uv.h".}
  Source
proc udp_recv_start(handle: PUdp; alloc_cb: AllocProc; recv_cb: UdpRecvProc): cint {.
    importc: "uv_udp_recv_start", header: "uv.h".}
  Source
proc udp_recv_stop(handle: PUdp): cint {.importc: "uv_udp_recv_stop", 
    header: "uv.h".}
  Source
proc tty_init(a2: PLoop; a3: pTTy; fd: File): cint {.importc: "uv_tty_init", 
    header: "uv.h".}
  Source
proc tty_set_mode(a2: pTTy; mode: cint): cint {.importc: "uv_tty_set_mode", 
    header: "uv.h".}
  Source
proc tty_get_winsize(a2: pTTy; width: var cint; height: var cint): cint {.
    importc: "uv_tty_get_winsize", header: "uv.h".}
  Source
proc tty_reset_mode() {.importc: "uv_tty_reset_mode", header: "uv.h".}
  Source
proc guess_handle(file: File): THandleType {.importc: "uv_guess_handle", 
    header: "uv.h".}
  Source
proc pipe_init(a2: PLoop; handle: PPipe; ipc: int): cint {.
    importc: "uv_pipe_init", header: "uv.h".}
  Source
proc pipe_open(a2: PPipe; file: File) {.importc: "uv_pipe_open", header: "uv.h".}
  Source
proc pipe_bind(handle: PPipe; name: cstring): cint {.importc: "uv_pipe_bind", 
    header: "uv.h".}
  Source
proc pipe_connect(req: PConnect; handle: PPipe; name: cstring; cb: ConnectProc): cint {.
    importc: "uv_pipe_connect", header: "uv.h".}
  Source
proc prepare_init(a2: PLoop; prepare: PPrepare): cint {.
    importc: "uv_prepare_init", header: "uv.h".}
  Source
proc prepare_start(prepare: PPrepare; cb: PrepareProc): cint {.
    importc: "uv_prepare_start", header: "uv.h".}
  Source
proc prepare_stop(prepare: PPrepare): cint {.importc: "uv_prepare_stop", 
    header: "uv.h".}
  Source
proc check_init(a2: PLoop; check: PCheck): cint {.importc: "uv_check_init", 
    header: "uv.h".}
  Source
proc check_start(check: PCheck; cb: CheckProc): cint {.
    importc: "uv_check_start", header: "uv.h".}
  Source
proc check_stop(check: PCheck): cint {.importc: "uv_check_stop", header: "uv.h".}
  Source
proc idle_init(a2: PLoop; idle: PIdle): cint {.importc: "uv_idle_init", 
    header: "uv.h".}
  Source
proc idle_start(idle: PIdle; cb: IdleProc): cint {.importc: "uv_idle_start", 
    header: "uv.h".}
  Source
proc idle_stop(idle: PIdle): cint {.importc: "uv_idle_stop", header: "uv.h".}
  Source
proc async_init(a2: PLoop; async: PAsync; async_cb: AsyncProc): cint {.
    importc: "uv_async_init", header: "uv.h".}
  Source
proc async_send(async: PAsync): cint {.importc: "uv_async_send", header: "uv.h".}
  Source
proc timer_init(a2: PLoop; timer: PTimer): cint {.importc: "uv_timer_init", 
    header: "uv.h".}
  Source
proc timer_start(timer: PTimer; cb: TimerProc; timeout: int64; repeat: int64): cint {.
    importc: "uv_timer_start", header: "uv.h".}
  Source
proc timer_stop(timer: PTimer): cint {.importc: "uv_timer_stop", header: "uv.h".}
  Source
proc timer_again(timer: PTimer): cint {.importc: "uv_timer_again", 
                                        header: "uv.h".}
  Source
proc timer_set_repeat(timer: PTimer; repeat: int64) {.
    importc: "uv_timer_set_repeat", header: "uv.h".}
  Source
proc timer_get_repeat(timer: PTimer): int64 {.importc: "uv_timer_get_repeat", 
    header: "uv.h".}
  Source
proc ares_init_options(a2: PLoop; channel: PAresChannel; options: PAresOptions; 
                       optmask: cint): cint {.importc: "uv_ares_init_options", 
    header: "uv.h".}
  Source
proc ares_destroy(a2: PLoop; channel: PAresChannel) {.
    importc: "uv_ares_destroy", header: "uv.h".}
  Source
proc getaddrinfo(a2: PLoop; handle: PGetAddrInfo; 
                 getaddrinfo_cb: GetAddrInfoProc; node: cstring; 
                 service: cstring; hints: ptr AddrInfo): cint {.
    importc: "uv_getaddrinfo", header: "uv.h".}
  Source
proc freeaddrinfo(ai: ptr AddrInfo) {.importc: "uv_freeaddrinfo", header: "uv.h".}
  Source
proc spawn(a2: PLoop; a3: PProcess; options: TProcessOptions): cint {.
    importc: "uv_spawn", header: "uv.h".}
  Source
proc process_kill(a2: PProcess; signum: cint): cint {.
    importc: "uv_process_kill", header: "uv.h".}
  Source
proc queue_work(loop: PLoop; req: PWork; work_cb: WorkProc; 
                after_work_cb: AfterWorkProc): cint {.importc: "uv_queue_work", 
    header: "uv.h".}
  Source
proc req_cleanup(req: PFS) {.importc: "uv_fs_req_cleanup", header: "uv.h".}
  Source
proc close(loop: PLoop; req: PFS; file: File; cb: FsProc): cint {.
    importc: "uv_fs_close", header: "uv.h".}
  Source
proc open(loop: PLoop; req: PFS; path: cstring; flags: cint; mode: cint; 
          cb: FsProc): cint {.importc: "uv_fs_open", header: "uv.h".}
  Source
proc read(loop: PLoop; req: PFS; file: File; buf: pointer; length: csize; 
          offset: coff; cb: FsProc): cint {.importc: "uv_fs_read", 
    header: "uv.h".}
  Source
  Source
proc write(loop: PLoop; req: PFS; file: File; buf: pointer; length: csize; 
           offset: coff; cb: FsProc): cint {.importc: "uv_fs_write", 
    header: "uv.h".}
  Source
proc mkdir(loop: PLoop; req: PFS; path: cstring; mode: cint; cb: FsProc): cint {.
    importc: "uv_fs_mkdir", header: "uv.h".}
  Source
proc rmdir(loop: PLoop; req: PFS; path: cstring; cb: FsProc): cint {.
    importc: "uv_fs_rmdir", header: "uv.h".}
  Source
proc readdir(loop: PLoop; req: PFS; path: cstring; flags: cint; cb: FsProc): cint {.
    importc: "uv_fs_readdir", header: "uv.h".}
  Source
proc stat(loop: PLoop; req: PFS; path: cstring; cb: FsProc): cint {.
    importc: "uv_fs_stat", header: "uv.h".}
  Source
proc fstat(loop: PLoop; req: PFS; file: File; cb: FsProc): cint {.
    importc: "uv_fs_fstat", header: "uv.h".}
  Source
proc rename(loop: PLoop; req: PFS; path: cstring; new_path: cstring; cb: FsProc): cint {.
    importc: "uv_fs_rename", header: "uv.h".}
  Source
proc fsync(loop: PLoop; req: PFS; file: File; cb: FsProc): cint {.
    importc: "uv_fs_fsync", header: "uv.h".}
  Source
proc fdatasync(loop: PLoop; req: PFS; file: File; cb: FsProc): cint {.
    importc: "uv_fs_fdatasync", header: "uv.h".}
  Source
proc ftruncate(loop: PLoop; req: PFS; file: File; offset: coff; cb: FsProc): cint {.
    importc: "uv_fs_ftruncate", header: "uv.h".}
  Source
proc sendfile(loop: PLoop; req: PFS; out_fd: File; in_fd: File; in_offset: coff; 
              length: csize; cb: FsProc): cint {.importc: "uv_fs_sendfile", 
    header: "uv.h".}
  Source
proc chmod(loop: PLoop; req: PFS; path: cstring; mode: cint; cb: FsProc): cint {.
    importc: "uv_fs_chmod", header: "uv.h".}
  Source
proc utime(loop: PLoop; req: PFS; path: cstring; atime: cdouble; mtime: cdouble; 
           cb: FsProc): cint {.importc: "uv_fs_utime", header: "uv.h".}
  Source
proc futime(loop: PLoop; req: PFS; file: File; atime: cdouble; mtime: cdouble; 
            cb: FsProc): cint {.importc: "uv_fs_futime", header: "uv.h".}
  Source
proc lstat(loop: PLoop; req: PFS; path: cstring; cb: FsProc): cint {.
    importc: "uv_fs_lstat", header: "uv.h".}
  Source
  Source
  Source
  Source
proc fchmod(loop: PLoop; req: PFS; file: File; mode: cint; cb: FsProc): cint {.
    importc: "uv_fs_fchmod", header: "uv.h".}
  Source
proc chown(loop: PLoop; req: PFS; path: cstring; uid: cint; gid: cint; 
           cb: FsProc): cint {.importc: "uv_fs_chown", header: "uv.h".}
  Source
proc fchown(loop: PLoop; req: PFS; file: File; uid: cint; gid: cint; cb: FsProc): cint {.
    importc: "uv_fs_fchown", header: "uv.h".}
  Source
proc event_init(loop: PLoop; handle: PFsEvent; filename: cstring; 
                cb: FsEventProc): cint {.importc: "uv_fs_event_init", 
    header: "uv.h".}
  Source
proc ip4_addr(ip: cstring; port: cint): Sockaddr_in {.importc: "uv_ip4_addr", 
    header: "uv.h".}
  Source
proc ip6_addr(ip: cstring; port: cint): Tsockaddr_in6 {.importc: "uv_ip6_addr", 
    header: "uv.h".}
  Source
proc ip4_name(src: ptr Sockaddr_in; dst: cstring; size: csize): cint {.
    importc: "uv_ip4_name", header: "uv.h".}
  Source
proc ip6_name(src: ptr Tsockaddr_in6; dst: cstring; size: csize): cint {.
    importc: "uv_ip6_name", header: "uv.h".}
  Source
proc exepath(buffer: cstring; size: var csize): cint {.importc: "uv_exepath", 
    header: "uv.h".}
  Source
proc hrtime(): uint64 {.importc: "uv_hrtime", header: "uv.h".}
  Source
proc loadavg(load: var array[0 .. 2, cdouble]) {.importc: "uv_loadavg", 
    header: "uv.h".}
  Source
proc get_free_memory(): cdouble {.importc: "uv_get_free_memory", header: "uv.h".}
  Source
proc get_total_memory(): cdouble {.importc: "uv_get_total_memory", 
                                   header: "uv.h".}
  Source