Buffer = object
  base* {.
importc: "base"
.}: pointer ## Pointer to the base of the buffer.
  length* {.
importc: "len"
.}: csize ## Total bytes in the buffer.
  

FileHandle = cint

SocketHandle = posix.SocketHandle

FD = cint

cssize = int

MallocProc = proc (size: csize): pointer {.
cdecl
.}

ReallocProc = proc (p: pointer; size: csize): pointer {.
cdecl
.}

CallocProc = proc (count: csize; size: csize): pointer {.
cdecl
.}

FreeProc = proc (p: pointer) {.
cdecl
.}

TimeVal = object
  second* {.
importc: "tv_sec"
.}: clong
  usecond* {.
importc: "tv_usec"
.}: clong

ResourceUsage = object
  utime* {.
importc: "ru_utime"
.}: TimeVal ## user CPU time used
  stime* {.
importc: "ru_stime"
.}: TimeVal ## system CPU time used
  maxrss* {.
importc: "ru_maxrss"
.}: uint64 ## maximum resident set size
  ixrss* {.
importc: "ru_ixrss"
.}: uint64 ## integral shared memory size (X)
  idrss* {.
importc: "ru_idrss"
.}: uint64 ## integral unshared data size (X)
  isrss* {.
importc: "ru_isrss"
.}: uint64 ## integral unshared stack size (X)
  minflt* {.
importc: "ru_minflt"
.}: uint64 ## page reclaims (soft page faults) (X)
  majflt* {.
importc: "ru_majflt"
.}: uint64 ## page faults (hard page faults) (X)
  nswap* {.
importc: "ru_nswap"
.}: uint64 ## swaps (X)
  inblock* {.
importc: "ru_inblock"
.}: uint64 ## block input operations
  oublock* {.
importc: "ru_oublock"
.}: uint64 ## block output operations
  msgsnd* {.
importc: "ru_msgsnd"
.}: uint64 ## IPC messages sent (X)
  msgrcv* {.
importc: "ru_msgrcv"
.}: uint64 ## IPC messages received (X)
  nsignals* {.
importc: "ru_nsignals"
.}: uint64 ## signals received (X)
  nvcsw* {.
importc: "ru_nvcsw"
.}: uint64 ## voluntary context switches (X)
  nivcsw* {.
importc: "ru_nivcsw"
.}: uint64 ## involuntary context switches (X)
  

CpuTimes = object
  user*: uint64
  nice*: uint64
  sys*: uint64
  idle*: uint64
  irq*: uint64

CpuInfo = object
  model*: cstring
  speed*: cint
  cpuTimes* {.
importc: "cpu_times"
.}: CpuTimes

SockAddrN = object {.
union
.}
  address4* {.
importc: "address4"
.}: Sockaddr_in
  address6* {.
importc: "address6"
.}: Sockaddr_in6

InterfaceAddress = object
  name* {.
importc: "name"
.}: cstring
  physAddr* {.
importc: "phys_addr"
.}: array[6, char]
  isInternal* {.
importc: "is_internal"
.}: cint
  address* {.
importc: "address"
.}: SockAddrN
  netmask* {.
importc: "netmask"
.}: SockAddrN

Password = object
  username*: cstring
  uid*: clong
  gid*: clong
  shell*: cstring
  homedir*: cstring

proc replaceAllocator(malloc: MallocProc; realloc: ReallocProc; calloc: CallocProc;
                     free: FreeProc): cint {.
importc: "uv_replace_allocator",
    header: "uv.h"
.}

proc initBuffer(base: pointer; length: cuint): Buffer {.
importc: "uv_buf_init",
    header: "uv.h"
.}

proc setupArgs(argc: cint; argv: cstringArray): cstringArray {.

    importc: "uv_setup_args", header: "uv.h"
.}

proc getProcessTitle(buffer: cstring; size: csize): cint {.

    importc: "uv_get_process_title", header: "uv.h"
.}

proc setProcessTitle(title: cstring): cint {.
importc: "uv_set_process_title",
    header: "uv.h"
.}

proc getResidentSetMemory(rss: var csize): cint {.
importc: "uv_resident_set_memory",
    header: "uv.h"
.}

proc getUpTime(uptime: var cdouble): cint {.
importc: "uv_uptime", header: "uv.h"
.}

proc getResourceUsage(rusage: var ResourceUsage): cint {.
importc: "uv_getrusage",
    header: "uv.h"
.}

proc getCpuInfo(cpuInfos: var ptr CpuInfo; count: var cint): cint {.

    importc: "uv_cpu_info", header: "uv.h"
.}

proc freeCpuInfo(cpuInfos: ptr CpuInfo; count: cint) {.
importc: "uv_free_cpu_info",
    header: "uv.h"
.}

proc getInterfaceAddresses(addresses: var ptr InterfaceAddress; count: var cint): cint {.

    importc: "uv_interface_addresses", header: "uv.h"
.}

proc freeInterfaceAddresses(addresses: ptr InterfaceAddress; count: cint) {.

    importc: "uv_free_interface_addresses", header: "uv.h"
.}

proc getLoadAverage(avg: var array[3, cdouble]) {.
importc: "uv_loadavg", header: "uv.h"
.}

proc toIp4Addr(ip: cstring; port: cint; sockAddr: var Sockaddr_in): cint {.

    importc: "uv_ip4_addr", header: "uv.h"
.}

proc toIp6Addr(ip: cstring; port: cint; sockAddr: var Sockaddr_in6): cint {.

    importc: "uv_ip6_addr", header: "uv.h"
.}

proc toIp4Name(src: ptr Sockaddr_in; dst: cstring; size: csize): cint {.

    importc: "uv_ip4_name", header: "uv.h"
.}

proc toIp6Name(src: ptr Sockaddr_in6; dst: cstring; size: csize): cint {.

    importc: "uv_ip6_name", header: "uv.h"
.}

proc inetNtop(af: cint; src: pointer; dst: cstring; size: csize): cint {.

    importc: "uv_inet_ntop", header: "uv.h"
.}

proc inetPton(af: cint; src: cstring; dst: pointer): cint {.
importc: "uv_inet_pton",
    header: "uv.h"
.}

proc getExePath(buffer: cstring; size: var csize): cint {.
importc: "uv_exepath",
    header: "uv.h"
.}

proc getCurrentDir(buffer: cstring; size: var csize): cint {.
importc: "uv_cwd",
    header: "uv.h"
.}

proc chgCurrentDir(dir: cstring): cint {.
importc: "uv_chdir", header: "uv.h"
.}

proc getHomeDir(buffer: cstring; size: var csize): cint {.
importc: "uv_os_homedir",
    header: "uv.h"
.}

proc getTpmDir(buffer: cstring; size: var csize): cint {.
importc: "uv_os_tmpdir",
    header: "uv.h"
.}

proc getPassword(pwd: var Password): cint {.
importc: "uv_os_get_passwd", header: "uv.h"
.}

proc freePassword(pwd: var Password) {.
importc: "uv_os_free_passwd", header: "uv.h"
.}

proc getTotalMemory(): uint64 {.
importc: "uv_get_total_memory", header: "uv.h"
.}

proc hrTime(): uint64 {.
importc: "uv_hrtime", header: "uv.h"
.}