AddrInfo {.importc: "struct addrinfo", pure, final, header: "<netdb.h>".} = object
  ai_flags*: cint            ## Input flags.
  ai_family*: cint           ## Address family of socket.
  ai_socktype*: cint         ## Socket type.
  ai_protocol*: cint         ## Protocol of socket.
  ai_addrlen*: SockLen       ## Length of socket address.
  ai_addr*: ptr SockAddr     ## Socket address of socket.
  ai_canonname*: cstring     ## Canonical name of service location.
  ai_next*: ptr AddrInfo     ## Pointer to next in list.

Blkcnt {.importc: "blkcnt_t", header: "<sys/types.h>".} = int

Blksize {.importc: "blksize_t", header: "<sys/types.h>".} = int

Clock {.importc: "clock_t", header: "<sys/types.h>".} = int

ClockId {.importc: "clockid_t", header: "<sys/types.h>".} = int

Dev {.importc: "dev_t", header: "<sys/types.h>".} = int

DIR {.importc: "DIR", header: "<dirent.h>", incompleteStruct.} = object

Dirent {.importc: "struct dirent", header: "<dirent.h>", final, pure.} = object
  when defined(haiku):
    d_dev*: Dev              ## Device (not POSIX)
    d_pdev*: Dev             ## Parent device (only for queries) (not POSIX)
  d_ino*: Ino                ## File serial number.
  when defined(dragonfly):
    d_type*: uint8
  elif defined(linux) or defined(macosx) or defined(freebsd) or defined(netbsd) or
      defined(openbsd) or
      defined(genode):
    d_reclen*: cshort        ## Length of this record. (not POSIX)
    d_type*: int8 ## Type of file; not supported by all filesystem types.
                  ## (not POSIX)
    when defined(linux) or defined(openbsd):
      d_off*: Off            ## Not an offset. Value that `telldir()` would return.
  elif defined(haiku):
    d_pino*: Ino             ## Parent inode (only for queries) (not POSIX)
    d_reclen*: cushort       ## Length of this record. (not POSIX)
  d_name*: array[0 .. 255, char] ## Name of entry.

Fsblkcnt {.importc: "fsblkcnt_t", header: "<sys/types.h>".} = int

Fsfilcnt {.importc: "fsfilcnt_t", header: "<sys/types.h>".} = int

FTW {.importc: "struct FTW", header: "<ftw.h>", final, pure.} = object
  base*: cint
  level*: cint

Gid {.importc: "gid_t", header: "<sys/types.h>".} = int

Glob {.importc: "glob_t", header: "<glob.h>", final, pure.} = object
  gl_pathc*: int             ## Count of paths matched by pattern.
  gl_pathv*: cstringArray    ## Pointer to a list of matched pathnames.
  gl_offs*: int              ## Slots to reserve at the beginning of gl_pathv.

Group {.importc: "struct group", header: "<grp.h>", final, pure.} = object
  gr_name*: cstring          ## The name of the group.
  gr_gid*: Gid               ## Numerical group ID.
  gr_mem*: cstringArray      ## Pointer to a null-terminated array of character
                             ## pointers to member names.

Hostent {.importc: "struct hostent", pure, final, header: "<netdb.h>".} = object
  h_name*: cstring           ## Official name of the host.
  h_aliases*: cstringArray   ## A pointer to an array of pointers to
                             ## alternative host names, terminated by a
                             ## null pointer.
  h_addrtype*: cint          ## Address type.
  h_length*: cint            ## The length, in bytes, of the address.
  h_addr_list*: cstringArray ## A pointer to an array of pointers to network
                             ## addresses (in network byte order) for the
                             ## host, terminated by a null pointer.

Iconv {.importc: "iconv_t", header: "<iconv.h>", final, pure.} = object

Id {.importc: "id_t", header: "<sys/types.h>".} = int

In6Addr {.importc: "struct in6_addr", pure, final, header: "<netinet/in.h>".} = object
  s6_addr*: array[0 .. 15, char]

InAddr {.importc: "struct in_addr", pure, final, header: "<netinet/in.h>".} = object
  s_addr*: InAddrScalar

InAddrScalar = uint32

InAddrT {.importc: "in_addr_t", pure, final, header: "<netinet/in.h>".} = uint32

Ino {.importc: "ino_t", header: "<sys/types.h>".} = int

InPort = uint16

IOVec {.importc: "struct iovec", pure, final, header: "<sys/uio.h>".} = object
  iov_base*: pointer         ## Base address of a memory region for input or output.
  iov_len*: csize_t          ## The size of the memory pointed to by iov_base.

Ipc_perm {.importc: "struct ipc_perm", header: "<sys/ipc.h>", final, pure.} = object
  uid*: Uid                  ## Owner's user ID.
  gid*: Gid                  ## Owner's group ID.
  cuid*: Uid                 ## Creator's user ID.
  cgid*: Gid                 ## Creator's group ID.
  mode*: Mode                ## Read/write permission.

Itimerspec {.importc: "struct itimerspec", header: "<time.h>", final, pure.} = object
  it_interval*: Timespec     ## Timer period.
  it_value*: Timespec        ## Timer expiration.

Key {.importc: "key_t", header: "<sys/types.h>".} = int

Lconv {.importc: "struct lconv", header: "<locale.h>", final, pure.} = object
  currency_symbol*: cstring
  decimal_point*: cstring
  frac_digits*: char
  grouping*: cstring
  int_curr_symbol*: cstring
  int_frac_digits*: char
  int_n_cs_precedes*: char
  int_n_sep_by_space*: char
  int_n_sign_posn*: char
  int_p_cs_precedes*: char
  int_p_sep_by_space*: char
  int_p_sign_posn*: char
  mon_decimal_point*: cstring
  mon_grouping*: cstring
  mon_thousands_sep*: cstring
  negative_sign*: cstring
  n_cs_precedes*: char
  n_sep_by_space*: char
  n_sign_posn*: char
  positive_sign*: cstring
  p_cs_precedes*: char
  p_sep_by_space*: char
  p_sign_posn*: char
  thousands_sep*: cstring

Mcontext {.importc: "mcontext_t", header: "<ucontext.h>", final, pure.} = object

Mode {.importc: "mode_t", header: "<sys/types.h>".} = (when false or false:
  uint16
 else:
  uint32)

MqAttr {.importc: "struct mq_attr", header: "<mqueue.h>", final, pure.} = object
  mq_flags*: int             ## Message queue flags.
  mq_maxmsg*: int            ## Maximum number of messages.
  mq_msgsize*: int           ## Maximum message size.
  mq_curmsgs*: int           ## Number of messages currently queued.

Mqd {.importc: "mqd_t", header: "<mqueue.h>", final, pure.} = object

Nl_catd {.importc: "nl_catd", header: "<nl_types.h>".} = cint

Nl_item {.importc: "nl_item", header: "<nl_types.h>".} = cint

Nlink {.importc: "nlink_t", header: "<sys/types.h>".} = int

Off {.importc: "off_t", header: "<sys/types.h>".} = int64

Passwd {.importc: "struct passwd", header: "<pwd.h>", final, pure.} = object
  pw_name*: cstring          ## User's login name.
  pw_uid*: Uid               ## Numerical user ID.
  pw_gid*: Gid               ## Numerical group ID.
  pw_dir*: cstring           ## Initial working directory.
  pw_shell*: cstring         ## Program to use as shell.

Pid {.importc: "pid_t", header: "<sys/types.h>".} = int32

Posix_typed_mem_info {.importc: "struct posix_typed_mem_info",
                       header: "<sys/mman.h>", final, pure.} = object
  posix_tmi_length*: int

Protoent {.importc: "struct protoent", pure, final, header: "<netdb.h>".} = object
  p_name*: cstring           ## Official name of the protocol.
  p_aliases*: cstringArray   ## A pointer to an array of pointers to
                             ## alternative protocol names, terminated by
                             ## a null pointer.
  p_proto*: cint             ## The protocol number.

Pthread {.importc: "pthread_t", header: "<sys/types.h>".} = int

Pthread_attr {.importc: "pthread_attr_t", header: "<sys/types.h>".} = int

Pthread_barrier {.importc: "pthread_barrier_t", header: "<sys/types.h>".} = int

Pthread_barrierattr {.importc: "pthread_barrierattr_t", header: "<sys/types.h>".} = int

Pthread_cond {.importc: "pthread_cond_t", header: "<sys/types.h>".} = int

Pthread_condattr {.importc: "pthread_condattr_t", header: "<sys/types.h>".} = int

Pthread_key {.importc: "pthread_key_t", header: "<sys/types.h>".} = int

Pthread_mutex {.importc: "pthread_mutex_t", header: "<sys/types.h>".} = int

Pthread_mutexattr {.importc: "pthread_mutexattr_t", header: "<sys/types.h>".} = int

Pthread_once {.importc: "pthread_once_t", header: "<sys/types.h>".} = int

Pthread_rwlock {.importc: "pthread_rwlock_t", header: "<sys/types.h>".} = int

Pthread_rwlockattr {.importc: "pthread_rwlockattr_t", header: "<sys/types.h>".} = int

Pthread_spinlock {.importc: "pthread_spinlock_t", header: "<sys/types.h>".} = int

RLimit {.importc: "struct rlimit", header: "<sys/resource.h>", pure, final.} = object
  rlim_cur*: int
  rlim_max*: int

Rusage {.importc: "struct rusage", header: "<sys/resource.h>", bycopy.} = object
  ru_utime*, ru_stime*: Timeval
  ru_maxrss*, ru_ixrss*, ru_idrss*, ru_isrss*, ru_minflt*, ru_majflt*,
  ru_nswap*, ru_inblock*, ru_oublock*, ru_msgsnd*, ru_msgrcv*, ru_nsignals*,
  ru_nvcsw*, ru_nivcsw*: clong

Sched_param {.importc: "struct sched_param", header: "<sched.h>", final, pure.} = object
  sched_priority*: cint
  sched_ss_low_priority*: cint ## Low scheduling priority for
                               ## sporadic server.
  sched_ss_repl_period*: Timespec ## Replenishment period for
                                  ## sporadic server.
  sched_ss_init_budget*: Timespec ## Initial budget for sporadic server.
  sched_ss_max_repl*: cint   ## Maximum pending replenishments for
                             ## sporadic server.

Sem {.importc: "sem_t", header: "<semaphore.h>", final, pure.} = object

Servent {.importc: "struct servent", pure, final, header: "<netdb.h>".} = object
  s_name*: cstring           ## Official name of the service.
  s_aliases*: cstringArray   ## A pointer to an array of pointers to
                             ## alternative service names, terminated by
                             ## a null pointer.
  s_port*: cint              ## The port number at which the service
                             ## resides, in network byte order.
  s_proto*: cstring          ## The name of the protocol to use when
                             ## contacting the service.

Sig_atomic {.importc: "sig_atomic_t", header: "<signal.h>".} = cint

Sigaction {.importc: "struct sigaction", header: "<signal.h>", final, pure.} = object
  sa_handler*: proc (x: cint) {.noconv.} ## Pointer to a signal-catching
                                         ## function or one of the macros
                                         ## SIG_IGN or SIG_DFL.
  sa_mask*: Sigset           ## Set of signals to be blocked during execution of
                             ## the signal handling function.
  sa_flags*: cint            ## Special flags.
  sa_sigaction*: proc (x: cint; y: ptr SigInfo; z: pointer) {.noconv.}

SigEvent {.importc: "struct sigevent", header: "<signal.h>", final, pure.} = object
  sigev_notify*: cint        ## Notification type.
  sigev_signo*: cint         ## Signal number.
  sigev_value*: SigVal       ## Signal value.
  sigev_notify_function*: proc (x: SigVal) {.noconv.} ## Notification func.
  sigev_notify_attributes*: ptr Pthread_attr ## Notification attributes.

SigInfo {.importc: "siginfo_t", header: "<signal.h>", final, pure.} = object
  si_signo*: cint            ## Signal number.
  si_code*: cint             ## Signal code.
  si_errno*: cint            ## If non-zero, an errno value associated with
                             ## this signal, as defined in <errno.h>.
  si_pid*: Pid               ## Sending process ID.
  si_uid*: Uid               ## Real user ID of sending process.
  si_addr*: pointer          ## Address of faulting instruction.
  si_status*: cint           ## Exit value or signal.
  si_band*: int              ## Band event for SIGPOLL.
  si_value*: SigVal          ## Signal value.

Sigset {.importc: "sigset_t", header: "<signal.h>", final, pure.} = object

SigStack {.importc: "struct sigstack", header: "<signal.h>", final, pure.} = object
  ss_onstack*: cint          ## Non-zero when signal stack is in use.
  ss_sp*: pointer            ## Signal stack pointer.

SigVal {.importc: "union sigval", header: "<signal.h>", final, pure.} = object
  sival_ptr*: pointer        ## pointer signal value;
                             ## integer signal value not defined!

SockAddr {.importc: "struct sockaddr", header: "<sys/socket.h>", pure, final.} = object
  sa_family*: TSa_Family     ## Address family.
  sa_data*: array[0 .. 255 - 2, char] ## Socket address (variable-length data).

Sockaddr_in {.importc: "struct sockaddr_in", pure, final,
              header: "<netinet/in.h>".} = object
  sin_family*: TSa_Family    ## AF_INET.
  sin_port*: InPort          ## Port number.
  sin_addr*: InAddr          ## IP address.

Sockaddr_in6 {.importc: "struct sockaddr_in6", pure, final,
               header: "<netinet/in.h>".} = object
  sin6_family*: TSa_Family   ## AF_INET6.
  sin6_port*: InPort         ## Port number.
  sin6_flowinfo*: int32      ## IPv6 traffic class and flow information.
  sin6_addr*: In6Addr        ## IPv6 address.
  sin6_scope_id*: int32      ## Set of interfaces for a scope.

Sockaddr_storage {.importc: "struct sockaddr_storage", header: "<sys/socket.h>",
                   pure, final.} = object
  ss_family*: TSa_Family     ## Address family.

Sockaddr_un {.importc: "struct sockaddr_un", header: "<sys/un.h>", pure, final.} = object
  sun_family*: TSa_Family    ## Address family.
  sun_path*: array[0 .. 92 - 2, char] ## Socket path

SocketHandle = distinct cint

SockLen {.importc: "socklen_t", header: "<sys/socket.h>".} = cuint

Stack {.importc: "stack_t", header: "<signal.h>", final, pure.} = object
  ss_sp*: pointer            ## Stack base or pointer.
  ss_size*: int              ## Stack size.
  ss_flags*: cint            ## Flags.

Stat {.importc: "struct stat", header: "<sys/stat.h>", final, pure.} = object
  st_dev*: Dev               ## Device ID of device containing file.
  st_ino*: Ino               ## File serial number.
  st_mode*: Mode             ## Mode of file (see below).
  st_nlink*: Nlink           ## Number of hard links to the file.
  st_uid*: Uid               ## User ID of file.
  st_gid*: Gid               ## Group ID of file.
  st_rdev*: Dev              ## Device ID (if file is character or block special).
  st_size*: Off              ## For regular files, the file size in bytes.
                             ## For symbolic links, the length in bytes of the
                             ## pathname contained in the symbolic link.
                             ## For a shared memory object, the length in bytes.
                             ## For a typed memory object, the length in bytes.
                             ## For other file types, the use of this field is
                             ## unspecified.
  when StatHasNanoseconds:
    st_atim*: Timespec       ## Time of last access.
    st_mtim*: Timespec       ## Time of last data modification.
    st_ctim*: Timespec       ## Time of last status change.
  else:
    st_atime*: Time          ## Time of last access.
    st_mtime*: Time          ## Time of last data modification.
    st_ctime*: Time          ## Time of last status change.
  st_blksize*: Blksize       ## A file system-specific preferred I/O block size
                             ## for this object. In some file system types, this
                             ## may vary from file to file.
  st_blocks*: Blkcnt         ## Number of blocks allocated for this object.

Statvfs {.importc: "struct statvfs", header: "<sys/statvfs.h>", final, pure.} = object
  f_bsize*: int              ## File system block size.
  f_frsize*: int             ## Fundamental file system block size.
  f_blocks*: Fsblkcnt        ## Total number of blocks on file system
                             ## in units of f_frsize.
  f_bfree*: Fsblkcnt         ## Total number of free blocks.
  f_bavail*: Fsblkcnt        ## Number of free blocks available to
                             ## non-privileged process.
  f_files*: Fsfilcnt         ## Total number of file serial numbers.
  f_ffree*: Fsfilcnt         ## Total number of free file serial numbers.
  f_favail*: Fsfilcnt        ## Number of file serial numbers available to
                             ## non-privileged process.
  f_fsid*: int               ## File system ID.
  f_flag*: int               ## Bit mask of f_flag values.
  f_namemax*: int            ## Maximum filename length.

Suseconds {.importc: "suseconds_t", header: "<sys/types.h>".} = int

Tcmsghdr {.importc: "struct cmsghdr", pure, final, header: "<sys/socket.h>".} = object
  cmsg_len*: SockLen         ## Data byte count, including the cmsghdr.
  cmsg_level*: cint          ## Originating protocol.
  cmsg_type*: cint           ## Protocol-specific type.

TFdSet {.importc: "fd_set", header: "<sys/select.h>", final, pure.} = object

Tflock {.importc: "struct flock", final, pure, header: "<fcntl.h>".} = object
  l_type*: cshort            ## Type of lock; F_RDLCK, F_WRLCK, F_UNLCK.
  l_whence*: cshort          ## Flag for starting offset.
  l_start*: Off              ## Relative offset in bytes.
  l_len*: Off                ## Size; if 0 then until EOF.
  l_pid*: Pid                ## Process ID of the process holding the lock;
                             ## returned with F_GETLK.

Tif_nameindex {.importc: "struct if_nameindex", final, pure,
                header: "<net/if.h>".} = object
  if_index*: cint            ## Numeric index of the interface.
  if_name*: cstring          ## Null-terminated name of the interface.

Time {.importc: "time_t", header: "<time.h>".} = distinct (when defined(
    nimUse64BitCTime):
  int64
 else:
  clong)

Timer {.importc: "timer_t", header: "<sys/types.h>".} = int

Timespec {.importc: "struct timespec", header: "<time.h>", final, pure.} = object
  tv_sec*: Time              ## Seconds.
  tv_nsec*: int              ## Nanoseconds.

Timeval {.importc: "struct timeval", header: "<sys/select.h>", final, pure.} = object
  tv_sec*: Time              ## Seconds.
  tv_usec*: Suseconds        ## Microseconds.

Tipv6_mreq {.importc: "struct ipv6_mreq", pure, final, header: "<netinet/in.h>".} = object
  ipv6mr_multiaddr*: In6Addr ## IPv6 multicast address.
  ipv6mr_interface*: cint    ## Interface index.

TLinger {.importc: "struct linger", pure, final, header: "<sys/socket.h>".} = object
  l_onoff*: cint             ## Indicates whether linger option is enabled.
  l_linger*: cint            ## Linger time, in seconds.

Tm {.importc: "struct tm", header: "<time.h>", final, pure.} = object
  tm_sec*: cint              ## Seconds [0,60].
  tm_min*: cint              ## Minutes [0,59].
  tm_hour*: cint             ## Hour [0,23].
  tm_mday*: cint             ## Day of month [1,31].
  tm_mon*: cint              ## Month of year [0,11].
  tm_year*: cint             ## Years since 1900.
  tm_wday*: cint             ## Day of week [0,6] (Sunday =0).
  tm_yday*: cint             ## Day of year [0,365].
  tm_isdst*: cint            ## Daylight Savings flag.

Tmsghdr {.importc: "struct msghdr", pure, final, header: "<sys/socket.h>".} = object
  msg_name*: pointer         ## Optional address.
  msg_namelen*: SockLen      ## Size of address.
  msg_iov*: ptr IOVec        ## Scatter/gather array.
  msg_iovlen*: cint          ## Members in msg_iov.
  msg_control*: pointer      ## Ancillary data; see below.
  msg_controllen*: SockLen   ## Ancillary data buffer len.
  msg_flags*: cint           ## Flags on received message.

Tnetent {.importc: "struct netent", pure, final, header: "<netdb.h>".} = object
  n_name*: cstring           ## Official, fully-qualified (including the
                             ## domain) name of the host.
  n_aliases*: cstringArray   ## A pointer to an array of pointers to
                             ## alternative network names, terminated by a
                             ## null pointer.
  n_addrtype*: cint          ## The address type of the network.
  n_net*: int32              ## The network number, in host byte order.

Tnfds {.importc: "nfds_t", header: "<poll.h>".} = cint

TPollfd {.importc: "struct pollfd", pure, final, header: "<poll.h>".} = object
  fd*: cint                  ## The following descriptor being polled.
  events*: cshort            ## The input event flags (see below).
  revents*: cshort           ## The output event flags (see below).

Tposix_spawn_file_actions {.importc: "posix_spawn_file_actions_t",
                            header: "<spawn.h>", final, pure.} = object

Tposix_spawnattr {.importc: "posix_spawnattr_t", header: "<spawn.h>", final,
                   pure.} = object

Trace_attr {.importc: "trace_attr_t", header: "<sys/types.h>".} = int

Trace_event_id {.importc: "trace_event_id_t", header: "<sys/types.h>".} = int

Trace_event_set {.importc: "trace_event_set_t", header: "<sys/types.h>".} = int

Trace_id {.importc: "trace_id_t", header: "<sys/types.h>".} = int

TSa_Family {.importc: "sa_family_t", header: "<sys/socket.h>".} = cushort

Ucontext {.importc: "ucontext_t", header: "<ucontext.h>", final, pure.} = object
  uc_link*: ptr Ucontext     ## Pointer to the context that is resumed
                             ## when this context returns.
  uc_sigmask*: Sigset        ## The set of signals that are blocked when this
                             ## context is active.
  uc_stack*: Stack           ## The stack used by this context.
  uc_mcontext*: Mcontext     ## A machine-specific representation of the saved
                             ## context.

Uid {.importc: "uid_t", header: "<sys/types.h>".} = int

Useconds {.importc: "useconds_t", header: "<sys/types.h>".} = int

Utsname {.importc: "struct utsname", header: "<sys/utsname.h>", final, pure.} = object
  sysname*,                 ## Name of the hardware type on which the
                             ## system is running.
  ## Name of this implementation of the operating system.
  nodename*,                ## Name of this node within the communications
                             ## network to which this node is attached, if any.
  release*,                 ## Current release level of this implementation.
  version*,                 ## Current version level of this release.
  machine*: array[0 .. 255, char]

ABDAY_1 {.importc: "ABDAY_1", header: "<langinfo.h>".}: cint

ABDAY_2 {.importc: "ABDAY_2", header: "<langinfo.h>".}: cint

ABDAY_3 {.importc: "ABDAY_3", header: "<langinfo.h>".}: cint

ABDAY_4 {.importc: "ABDAY_4", header: "<langinfo.h>".}: cint

ABDAY_5 {.importc: "ABDAY_5", header: "<langinfo.h>".}: cint

ABDAY_6 {.importc: "ABDAY_6", header: "<langinfo.h>".}: cint

ABDAY_7 {.importc: "ABDAY_7", header: "<langinfo.h>".}: cint

ABMON_1 {.importc: "ABMON_1", header: "<langinfo.h>".}: cint

ABMON_2 {.importc: "ABMON_2", header: "<langinfo.h>".}: cint

ABMON_3 {.importc: "ABMON_3", header: "<langinfo.h>".}: cint

ABMON_4 {.importc: "ABMON_4", header: "<langinfo.h>".}: cint

ABMON_5 {.importc: "ABMON_5", header: "<langinfo.h>".}: cint

ABMON_6 {.importc: "ABMON_6", header: "<langinfo.h>".}: cint

ABMON_7 {.importc: "ABMON_7", header: "<langinfo.h>".}: cint

ABMON_8 {.importc: "ABMON_8", header: "<langinfo.h>".}: cint

ABMON_9 {.importc: "ABMON_9", header: "<langinfo.h>".}: cint

ABMON_10 {.importc: "ABMON_10", header: "<langinfo.h>".}: cint

ABMON_11 {.importc: "ABMON_11", header: "<langinfo.h>".}: cint

ABMON_12 {.importc: "ABMON_12", header: "<langinfo.h>".}: cint

AF_INET {.importc: "AF_INET", header: "<sys/socket.h>".}: cint

AF_INET6 {.importc: "AF_INET6", header: "<sys/socket.h>".}: cint

AF_UNIX {.importc: "AF_UNIX", header: "<sys/socket.h>".}: cint

AF_UNSPEC {.importc: "AF_UNSPEC", header: "<sys/socket.h>".}: cint

AI_ADDRCONFIG {.importc: "AI_ADDRCONFIG", header: "<netdb.h>".}: cint

AI_ALL {.importc: "AI_ALL", header: "<netdb.h>".}: cint

AI_CANONNAME {.importc: "AI_CANONNAME", header: "<netdb.h>".}: cint

AI_NUMERICHOST {.importc: "AI_NUMERICHOST", header: "<netdb.h>".}: cint

AI_NUMERICSERV {.importc: "AI_NUMERICSERV", header: "<netdb.h>".}: cint

AI_PASSIVE {.importc: "AI_PASSIVE", header: "<netdb.h>".}: cint

AI_V4MAPPED {.importc: "AI_V4MAPPED", header: "<netdb.h>".}: cint

AIO_ALLDONE {.importc: "AIO_ALLDONE", header: "<aio.h>".}: cint

AIO_CANCELED {.importc: "AIO_CANCELED", header: "<aio.h>".}: cint

AIO_NOTCANCELED {.importc: "AIO_NOTCANCELED", header: "<aio.h>".}: cint

ALT_DIGITS {.importc: "ALT_DIGITS", header: "<langinfo.h>".}: cint

AM_STR {.importc: "AM_STR", header: "<langinfo.h>".}: cint

CLOCK_MONOTONIC {.importc: "CLOCK_MONOTONIC", header: "<time.h>".}: cint

CLOCK_PROCESS_CPUTIME_ID {.importc: "CLOCK_PROCESS_CPUTIME_ID",
                           header: "<time.h>".}: cint

CLOCK_REALTIME {.importc: "CLOCK_REALTIME", header: "<time.h>".}: cint

CLOCK_THREAD_CPUTIME_ID {.importc: "CLOCK_THREAD_CPUTIME_ID", header: "<time.h>".}: cint

CLOCKS_PER_SEC {.importc: "CLOCKS_PER_SEC", header: "<time.h>".}: clong

CODESET {.importc: "CODESET", header: "<langinfo.h>".}: cint

CRNCYSTR {.importc: "CRNCYSTR", header: "<langinfo.h>".}: cint

CS_PATH {.importc: "_CS_PATH", header: "<unistd.h>".}: cint

CS_POSIX_V6_ILP32_OFF32_CFLAGS {.importc: "_CS_POSIX_V6_ILP32_OFF32_CFLAGS",
                                 header: "<unistd.h>".}: cint

CS_POSIX_V6_ILP32_OFF32_LDFLAGS {.importc: "_CS_POSIX_V6_ILP32_OFF32_LDFLAGS",
                                  header: "<unistd.h>".}: cint

CS_POSIX_V6_ILP32_OFF32_LIBS {.importc: "_CS_POSIX_V6_ILP32_OFF32_LIBS",
                               header: "<unistd.h>".}: cint

CS_POSIX_V6_ILP32_OFFBIG_CFLAGS {.importc: "_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS",
                                  header: "<unistd.h>".}: cint

CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS {.importc: "_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS",
                                   header: "<unistd.h>".}: cint

CS_POSIX_V6_ILP32_OFFBIG_LIBS {.importc: "_CS_POSIX_V6_ILP32_OFFBIG_LIBS",
                                header: "<unistd.h>".}: cint

CS_POSIX_V6_LP64_OFF64_CFLAGS {.importc: "_CS_POSIX_V6_LP64_OFF64_CFLAGS",
                                header: "<unistd.h>".}: cint

CS_POSIX_V6_LP64_OFF64_LDFLAGS {.importc: "_CS_POSIX_V6_LP64_OFF64_LDFLAGS",
                                 header: "<unistd.h>".}: cint

CS_POSIX_V6_LP64_OFF64_LIBS {.importc: "_CS_POSIX_V6_LP64_OFF64_LIBS",
                              header: "<unistd.h>".}: cint

CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS {.importc: "_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS",
                                  header: "<unistd.h>".}: cint

CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS {.importc: "_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS",
                                   header: "<unistd.h>".}: cint

CS_POSIX_V6_LPBIG_OFFBIG_LIBS {.importc: "_CS_POSIX_V6_LPBIG_OFFBIG_LIBS",
                                header: "<unistd.h>".}: cint

CS_POSIX_V6_WIDTH_RESTRICTED_ENVS {.importc: "_CS_POSIX_V6_WIDTH_RESTRICTED_ENVS",
                                    header: "<unistd.h>".}: cint

D_FMT {.importc: "D_FMT", header: "<langinfo.h>".}: cint

D_T_FMT {.importc: "D_T_FMT", header: "<langinfo.h>".}: cint

DAY_1 {.importc: "DAY_1", header: "<langinfo.h>".}: cint

DAY_2 {.importc: "DAY_2", header: "<langinfo.h>".}: cint

DAY_3 {.importc: "DAY_3", header: "<langinfo.h>".}: cint

DAY_4 {.importc: "DAY_4", header: "<langinfo.h>".}: cint

DAY_5 {.importc: "DAY_5", header: "<langinfo.h>".}: cint

DAY_6 {.importc: "DAY_6", header: "<langinfo.h>".}: cint

DAY_7 {.importc: "DAY_7", header: "<langinfo.h>".}: cint

daylight {.importc, header: "<time.h>".}: cint

E2BIG {.importc: "E2BIG", header: "<errno.h>".}: cint

EACCES {.importc: "EACCES", header: "<errno.h>".}: cint

EADDRINUSE {.importc: "EADDRINUSE", header: "<errno.h>".}: cint

EADDRNOTAVAIL {.importc: "EADDRNOTAVAIL", header: "<errno.h>".}: cint

EAFNOSUPPORT {.importc: "EAFNOSUPPORT", header: "<errno.h>".}: cint

EAGAIN {.importc: "EAGAIN", header: "<errno.h>".}: cint

EAI_AGAIN {.importc: "EAI_AGAIN", header: "<netdb.h>".}: cint

EAI_BADFLAGS {.importc: "EAI_BADFLAGS", header: "<netdb.h>".}: cint

EAI_FAIL {.importc: "EAI_FAIL", header: "<netdb.h>".}: cint

EAI_FAMILY {.importc: "EAI_FAMILY", header: "<netdb.h>".}: cint

EAI_MEMORY {.importc: "EAI_MEMORY", header: "<netdb.h>".}: cint

EAI_NONAME {.importc: "EAI_NONAME", header: "<netdb.h>".}: cint

EAI_OVERFLOW {.importc: "EAI_OVERFLOW", header: "<netdb.h>".}: cint

EAI_SERVICE {.importc: "EAI_SERVICE", header: "<netdb.h>".}: cint