Merge pull request #1760 from flrgh/feat/luv-annotations

add luv library annotations

24 files changed, 5108 insertions, 0 deletions

diff --git a/meta/3rd/luv/config.json b/meta/3rd/luv/config.json
new file mode 100644
index 00000000..70080322
--- /dev/null
+++ b/meta/3rd/luv/config.json
@@ -0,0 +1,8 @@
+{
+    "files" : [],
+    "words" : [
+        "require.*'luv'.*",
+        "require.*\"luv\".*"
+    ],
+    "settings" : {}
+}
diff --git a/meta/3rd/luv/library/errors.lua b/meta/3rd/luv/library/errors.lua
new file mode 100644
index 00000000..93184b87
--- /dev/null
+++ b/meta/3rd/luv/library/errors.lua
@@ -0,0 +1,261 @@
+---@meta
+
+---@alias uv.errno.E2BIG           "E2BIG"           # argument list too long.
+---@alias uv.errno.EACCES          "EACCES"          # permission denied.
+---@alias uv.errno.EADDRINUSE      "EADDRINUSE"      # address already in use.
+---@alias uv.errno.EADDRNOTAVAIL   "EADDRNOTAVAIL"   # address not available.
+---@alias uv.errno.EAFNOSUPPORT    "EAFNOSUPPORT"    # address family not supported.
+---@alias uv.errno.EAGAIN          "EAGAIN"          # resource temporarily unavailable.
+---@alias uv.errno.EAI_ADDRFAMILY  "EAI_ADDRFAMILY"  # address family not supported.
+---@alias uv.errno.EAI_AGAIN       "EAI_AGAIN"       # temporary failure.
+---@alias uv.errno.EAI_BADFLAGS    "EAI_BADFLAGS"    # bad ai_flags value.
+---@alias uv.errno.EAI_BADHINTS    "EAI_BADHINTS"    # invalid value for hints.
+---@alias uv.errno.EAI_CANCELED    "EAI_CANCELED"    # request canceled.
+---@alias uv.errno.EAI_FAIL        "EAI_FAIL"        # permanent failure.
+---@alias uv.errno.EAI_FAMILY      "EAI_FAMILY"      # ai_family not supported.
+---@alias uv.errno.EAI_MEMORY      "EAI_MEMORY"      # out of memory.
+---@alias uv.errno.EAI_NODATA      "EAI_NODATA"      # no address.
+---@alias uv.errno.EAI_NONAME      "EAI_NONAME"      # unknown node or service.
+---@alias uv.errno.EAI_OVERFLOW    "EAI_OVERFLOW"    # argument buffer overflow.
+---@alias uv.errno.EAI_PROTOCOL    "EAI_PROTOCOL"    # resolved protocol is unknown.
+---@alias uv.errno.EAI_SERVICE     "EAI_SERVICE"     # service not available for socket type.
+---@alias uv.errno.EAI_SOCKTYPE    "EAI_SOCKTYPE"    # socket type not supported.
+---@alias uv.errno.EALREADY        "EALREADY"        # connection already in progress.
+---@alias uv.errno.EBADF           "EBADF"           # bad file descriptor.
+---@alias uv.errno.EBUSY           "EBUSY"           # resource busy or locked.
+---@alias uv.errno.ECANCELED       "ECANCELED"       # operation canceled.
+---@alias uv.errno.ECHARSET        "ECHARSET"        # invalid Unicode character.
+---@alias uv.errno.ECONNABORTED    "ECONNABORTED"    # software caused connection abort.
+---@alias uv.errno.ECONNREFUSED    "ECONNREFUSED"    # connection refused.
+---@alias uv.errno.ECONNRESET      "ECONNRESET"      # connection reset by peer.
+---@alias uv.errno.EDESTADDRREQ    "EDESTADDRREQ"    # destination address required.
+---@alias uv.errno.EEXIST          "EEXIST"          # file already exists.
+---@alias uv.errno.EFAULT          "EFAULT"          # bad address in system call argument.
+---@alias uv.errno.EFBIG           "EFBIG"           # file too large.
+---@alias uv.errno.EFTYPE          "EFTYPE"          # inappropriate file type or format.
+---@alias uv.errno.EHOSTUNREACH    "EHOSTUNREACH"    # host is unreachable.
+---@alias uv.errno.EILSEQ          "EILSEQ"          # illegal byte sequence.
+---@alias uv.errno.EINTR           "EINTR"           # interrupted system call.
+---@alias uv.errno.EINVAL          "EINVAL"          # invalid argument.
+---@alias uv.errno.EIO             "EIO"             # i/o error.
+---@alias uv.errno.EISCONN         "EISCONN"         # socket is already connected.
+---@alias uv.errno.EISDIR          "EISDIR"          # illegal operation on a directory.
+---@alias uv.errno.ELOOP           "ELOOP"           # too many symbolic links encountered.
+---@alias uv.errno.EMFILE          "EMFILE"          # too many open files.
+---@alias uv.errno.EMLINK          "EMLINK"          # too many links.
+---@alias uv.errno.EMSGSIZE        "EMSGSIZE"        # message too long.
+---@alias uv.errno.ENAMETOOLONG    "ENAMETOOLONG"    # name too long.
+---@alias uv.errno.ENETDOWN        "ENETDOWN"        # network is down.
+---@alias uv.errno.ENETUNREACH     "ENETUNREACH"     # network is unreachable.
+---@alias uv.errno.ENFILE          "ENFILE"          # file table overflow.
+---@alias uv.errno.ENOBUFS         "ENOBUFS"         # no buffer space available.
+---@alias uv.errno.ENODEV          "ENODEV"          # no such device.
+---@alias uv.errno.ENOENT          "ENOENT"          # no such file or directory.
+---@alias uv.errno.ENOMEM          "ENOMEM"          # not enough memory.
+---@alias uv.errno.ENONET          "ENONET"          # machine is not on the network.
+---@alias uv.errno.ENOPROTOOPT     "ENOPROTOOPT"     # protocol not available.
+---@alias uv.errno.ENOSPC          "ENOSPC"          # no space left on device.
+---@alias uv.errno.ENOSYS          "ENOSYS"          # function not implemented.
+---@alias uv.errno.ENOTCONN        "ENOTCONN"        # socket is not connected.
+---@alias uv.errno.ENOTDIR         "ENOTDIR"         # not a directory.
+---@alias uv.errno.ENOTEMPTY       "ENOTEMPTY"       # directory not empty.
+---@alias uv.errno.ENOTSOCK        "ENOTSOCK"        # socket operation on non-socket.
+---@alias uv.errno.ENOTSUP         "ENOTSUP"         # operation not supported on socket.
+---@alias uv.errno.ENOTTY          "ENOTTY"          # inappropriate ioctl for device.
+---@alias uv.errno.ENXIO           "ENXIO"           # no such device or address.
+---@alias uv.errno.EOF             "EOF"             # end of file.
+---@alias uv.errno.EOVERFLOW       "EOVERFLOW"       # value too large for defined data type.
+---@alias uv.errno.EPERM           "EPERM"           # operation not permitted.
+---@alias uv.errno.EPIPE           "EPIPE"           # broken pipe.
+---@alias uv.errno.EPROTO          "EPROTO"          # protocol error.
+---@alias uv.errno.EPROTONOSUPPORT "EPROTONOSUPPORT" # protocol not supported.
+---@alias uv.errno.EPROTOTYPE      "EPROTOTYPE"      # protocol wrong type for socket.
+---@alias uv.errno.ERANGE          "ERANGE"          # result too large.
+---@alias uv.errno.EROFS           "EROFS"           # read-only file system.
+---@alias uv.errno.ESHUTDOWN       "ESHUTDOWN"       # cannot send after transport endpoint shutdown.
+---@alias uv.errno.ESOCKTNOSUPPORT "ESOCKTNOSUPPORT" # socket type not supported.
+---@alias uv.errno.ESPIPE          "ESPIPE"          # invalid seek.
+---@alias uv.errno.ESRCH           "ESRCH"           # no such process.
+---@alias uv.errno.ETIMEDOUT       "ETIMEDOUT"       # connection timed out.
+---@alias uv.errno.ETXTBSY         "ETXTBSY"         # text file is busy.
+---@alias uv.errno.EXDEV           "EXDEV"           # cross-device link not permitted.
+---@alias uv.errno.UNKNOWN         "UNKNOWN"         # unknown error.
+
+
+--- An error string with the format {name}: {message}
+---
+--- * {name} is the error name provided internally by uv_err_name (e.g. "ENOENT")
+--- * {message} is a human-readable message provided internally by uv_strerror
+---
+---@alias uv.error.message string
+
+
+--- An error name string
+---
+---@alias uv.error.name
+---| "E2BIG"           # argument list too long
+---| "EACCES"          # permission denied
+---| "EADDRINUSE"      # address already in use
+---| "EADDRNOTAVAIL"   # address not available
+---| "EAFNOSUPPORT"    # address family not supported
+---| "EAGAIN"          # resource temporarily unavailable
+---| "EAI_ADDRFAMILY"  # address family not supported
+---| "EAI_AGAIN"       # temporary failure
+---| "EAI_BADFLAGS"    # bad ai_flags value
+---| "EAI_BADHINTS"    # invalid value for hints
+---| "EAI_CANCELED"    # request canceled
+---| "EAI_FAIL"        # permanent failure
+---| "EAI_FAMILY"      # ai_family not supported
+---| "EAI_MEMORY"      # out of memory
+---| "EAI_NODATA"      # no address
+---| "EAI_NONAME"      # unknown node or service
+---| "EAI_OVERFLOW"    # argument buffer overflow
+---| "EAI_PROTOCOL"    # resolved protocol is unknown
+---| "EAI_SERVICE"     # service not available for socket type
+---| "EAI_SOCKTYPE"    # socket type not supported
+---| "EALREADY"        # connection already in progress
+---| "EBADF"           # bad file descriptor
+---| "EBUSY"           # resource busy or locked
+---| "ECANCELED"       # operation canceled
+---| "ECHARSET"        # invalid Unicode character
+---| "ECONNABORTED"    # software caused connection abort
+---| "ECONNREFUSED"    # connection refused
+---| "ECONNRESET"      # connection reset by peer
+---| "EDESTADDRREQ"    # destination address required
+---| "EEXIST"          # file already exists
+---| "EFAULT"          # bad address in system call argument
+---| "EFBIG"           # file too large
+---| "EFTYPE"          # inappropriate file type or format
+---| "EHOSTUNREACH"    # host is unreachable
+---| "EILSEQ"          # illegal byte sequence
+---| "EINTR"           # interrupted system call
+---| "EINVAL"          # invalid argument
+---| "EIO"             # i/o error
+---| "EISCONN"         # socket is already connected
+---| "EISDIR"          # illegal operation on a directory
+---| "ELOOP"           # too many symbolic links encountered
+---| "EMFILE"          # too many open files
+---| "EMLINK"          # too many links
+---| "EMSGSIZE"        # message too long
+---| "ENAMETOOLONG"    # name too long
+---| "ENETDOWN"        # network is down
+---| "ENETUNREACH"     # network is unreachable
+---| "ENFILE"          # file table overflow
+---| "ENOBUFS"         # no buffer space available
+---| "ENODEV"          # no such device
+---| "ENOENT"          # no such file or directory
+---| "ENOMEM"          # not enough memory
+---| "ENONET"          # machine is not on the network
+---| "ENOPROTOOPT"     # protocol not available
+---| "ENOSPC"          # no space left on device
+---| "ENOSYS"          # function not implemented
+---| "ENOTCONN"        # socket is not connected
+---| "ENOTDIR"         # not a directory
+---| "ENOTEMPTY"       # directory not empty
+---| "ENOTSOCK"        # socket operation on non-socket
+---| "ENOTSUP"         # operation not supported on socket
+---| "ENOTTY"          # inappropriate ioctl for device
+---| "ENXIO"           # no such device or address
+---| "EOF"             # end of file
+---| "EOVERFLOW"       # value too large for defined data type
+---| "EPERM"           # operation not permitted
+---| "EPIPE"           # broken pipe
+---| "EPROTO"          # protocol error
+---| "EPROTONOSUPPORT" # protocol not supported
+---| "EPROTOTYPE"      # protocol wrong type for socket
+---| "ERANGE"          # result too large
+---| "EROFS"           # read-only file system
+---| "ESHUTDOWN"       # cannot send after transport endpoint shutdown
+---| "ESOCKTNOSUPPORT" # socket type not supported
+---| "ESPIPE"          # invalid seek
+---| "ESRCH"           # no such process
+---| "ETIMEDOUT"       # connection timed out
+---| "ETXTBSY"         # text file is busy
+---| "EXDEV"           # cross-device link not permitted
+---| "UNKNOWN"         # unknown error
+
+
+--- A table value which exposes error constants as a map, where the key is the error name (without the UV_ prefix) and its value is a negative number.
+---
+---@class uv.errno : table
+---
+---@field E2BIG           integer # argument list too long.
+---@field EACCES          integer # permission denied.
+---@field EADDRINUSE      integer # address already in use.
+---@field EADDRNOTAVAIL   integer # address not available.
+---@field EAFNOSUPPORT    integer # address family not supported.
+---@field EAGAIN          integer # resource temporarily unavailable.
+---@field EAI_ADDRFAMILY  integer # address family not supported.
+---@field EAI_AGAIN       integer # temporary failure.
+---@field EAI_BADFLAGS    integer # bad ai_flags value.
+---@field EAI_BADHINTS    integer # invalid value for hints.
+---@field EAI_CANCELED    integer # request canceled.
+---@field EAI_FAIL        integer # permanent failure.
+---@field EAI_FAMILY      integer # ai_family not supported.
+---@field EAI_MEMORY      integer # out of memory.
+---@field EAI_NODATA      integer # no address.
+---@field EAI_NONAME      integer # unknown node or service.
+---@field EAI_OVERFLOW    integer # argument buffer overflow.
+---@field EAI_PROTOCOL    integer # resolved protocol is unknown.
+---@field EAI_SERVICE     integer # service not available for socket type.
+---@field EAI_SOCKTYPE    integer # socket type not supported.
+---@field EALREADY        integer # connection already in progress.
+---@field EBADF           integer # bad file descriptor.
+---@field EBUSY           integer # resource busy or locked.
+---@field ECANCELED       integer # operation canceled.
+---@field ECHARSET        integer # invalid Unicode character.
+---@field ECONNABORTED    integer # software caused connection abort.
+---@field ECONNREFUSED    integer # connection refused.
+---@field ECONNRESET      integer # connection reset by peer.
+---@field EDESTADDRREQ    integer # destination address required.
+---@field EEXIST          integer # file already exists.
+---@field EFAULT          integer # bad address in system call argument.
+---@field EFBIG           integer # file too large.
+---@field EFTYPE          integer # inappropriate file type or format.
+---@field EHOSTUNREACH    integer # host is unreachable.
+---@field EILSEQ          integer # illegal byte sequence.
+---@field EINTR           integer # interrupted system call.
+---@field EINVAL          integer # invalid argument.
+---@field EIO             integer # i/o error.
+---@field EISCONN         integer # socket is already connected.
+---@field EISDIR          integer # illegal operation on a directory.
+---@field ELOOP           integer # too many symbolic links encountered.
+---@field EMFILE          integer # too many open files.
+---@field EMLINK          integer # too many links.
+---@field EMSGSIZE        integer # message too long.
+---@field ENAMETOOLONG    integer # name too long.
+---@field ENETDOWN        integer # network is down.
+---@field ENETUNREACH     integer # network is unreachable.
+---@field ENFILE          integer # file table overflow.
+---@field ENOBUFS         integer # no buffer space available.
+---@field ENODEV          integer # no such device.
+---@field ENOENT          integer # no such file or directory.
+---@field ENOMEM          integer # not enough memory.
+---@field ENONET          integer # machine is not on the network.
+---@field ENOPROTOOPT     integer # protocol not available.
+---@field ENOSPC          integer # no space left on device.
+---@field ENOSYS          integer # function not implemented.
+---@field ENOTCONN        integer # socket is not connected.
+---@field ENOTDIR         integer # not a directory.
+---@field ENOTEMPTY       integer # directory not empty.
+---@field ENOTSOCK        integer # socket operation on non-socket.
+---@field ENOTSUP         integer # operation not supported on socket.
+---@field ENOTTY          integer # inappropriate ioctl for device.
+---@field ENXIO           integer # no such device or address.
+---@field EOF             integer # end of file.
+---@field EOVERFLOW       integer # value too large for defined data type.
+---@field EPERM           integer # operation not permitted.
+---@field EPIPE           integer # broken pipe.
+---@field EPROTO          integer # protocol error.
+---@field EPROTONOSUPPORT integer # protocol not supported.
+---@field EPROTOTYPE      integer # protocol wrong type for socket.
+---@field ERANGE          integer # result too large.
+---@field EROFS           integer # read-only file system.
+---@field ESHUTDOWN       integer # cannot send after transport endpoint shutdown.
+---@field ESOCKTNOSUPPORT integer # socket type not supported.
+---@field ESPIPE          integer # invalid seek.
+---@field ESRCH           integer # no such process.
+---@field ETIMEDOUT       integer # connection timed out.
+---@field ETXTBSY         integer # text file is busy.
+---@field EXDEV           integer # cross-device link not permitted.
+---@field UNKNOWN         integer # unknown error.
diff --git a/meta/3rd/luv/library/luv_dir_t.lua b/meta/3rd/luv/library/luv_dir_t.lua
new file mode 100644
index 00000000..34417802
--- /dev/null
+++ b/meta/3rd/luv/library/luv_dir_t.lua
@@ -0,0 +1,34 @@
+---@meta
+
+--- luv_dir_t
+---
+---@class uv.luv_dir_t : userdata
+local dir
+
+--- Closes a directory stream returned by a successful `uv.fs_opendir()` call.
+---
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(self:uv.luv_dir_t, callback:uv.fs_closedir.callback):uv.uv_fs_t
+function dir:closedir() end
+
+--- Iterates over the directory stream `luv_dir_t` returned by a successful
+--- `uv.fs_opendir()` call. A table of data tables is returned where the number
+--- of entries `n` is equal to or less than the `entries` parameter used in
+--- the associated `uv.fs_opendir()` call.
+---
+--- **Returns (sync version):** `table` or `fail`
+--- - `[1, 2, 3, ..., n]` : `table`
+---   - `name` : `string`
+---   - `type` : `string`
+---
+--- **Returns (async version):** `uv_fs_t userdata`
+---
+---@return uv.fs_readdir.entry[]|nil entries
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(self:uv.luv_dir_t, callback:uv.fs_readdir.callback):uv.uv_fs_t
+function dir:readdir() end
\ No newline at end of file
diff --git a/meta/3rd/luv/library/luv_thread_t.lua b/meta/3rd/luv/library/luv_thread_t.lua
new file mode 100644
index 00000000..3d199657
--- /dev/null
+++ b/meta/3rd/luv/library/luv_thread_t.lua
@@ -0,0 +1,20 @@
+---@meta
+
+--- luv_thread_t
+---
+---@class uv.luv_thread_t : userdata
+local thread
+
+--- Returns a boolean indicating whether two threads are the same. This function is
+--- equivalent to the `__eq` metamethod.
+---
+---@param other_thread uv.luv_thread_t
+---@return boolean
+function thread:equal(other_thread) end
+
+--- Waits for the `thread` to finish executing its entry function.
+---
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function thread:join() end
\ No newline at end of file
diff --git a/meta/3rd/luv/library/luv_work_ctx_t.lua b/meta/3rd/luv/library/luv_work_ctx_t.lua
new file mode 100644
index 00000000..790db995
--- /dev/null
+++ b/meta/3rd/luv/library/luv_work_ctx_t.lua
@@ -0,0 +1,17 @@
+---@meta
+
+--- luv_work_ctx_t
+---
+---@class uv.luv_work_ctx_t : userdata
+local work_ctx
+
+--- Queues a work request which will run `work_callback` in a new Lua state in a
+--- thread from the threadpool with any additional arguments from `...`. Values
+--- returned from `work_callback` are passed to `after_work_callback`, which is
+--- called in the main loop thread.
+---
+---@param  ...         uv.threadargs
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function work_ctx:queue(...) end
\ No newline at end of file
diff --git a/meta/3rd/luv/library/types.lua b/meta/3rd/luv/library/types.lua
new file mode 100644
index 00000000..57bce70c
--- /dev/null
+++ b/meta/3rd/luv/library/types.lua
@@ -0,0 +1,526 @@
+---@meta
+
+---@class uv.getrusage.result.time_t
+---@field sec integer
+---@field usec integer
+
+---@class uv.getrusage.result
+---
+---@field utime    uv.getrusage.result.time_t # user CPU time used
+---@field stime    uv.getrusage.result.time_t # system CPU time used
+---@field maxrss   integer                    # maximum resident set size
+---@field ixrss    integer                    # integral shared memory size
+---@field idrss    integer                    # integral unshared data size
+---@field isrss    integer                    # integral unshared stack size
+---@field minflt   integer                    # page reclaims (soft page faults)
+---@field majflt   integer                    # page faults (hard page faults)
+---@field nswap    integer                    # swaps
+---@field inblock  integer                    # block input operations
+---@field oublock  integer                    # block output operations
+---@field msgsnd   integer                    # IPC messages sent
+---@field msgrcv   integer                    # IPC messages received
+---@field nsignals integer                    # signals received
+---@field nvcsw    integer                    # voluntary context switches
+---@field nivcsw   integer                    # involuntary context switches
+
+
+---@alias uv.spawn.options.stdio.fd integer
+
+---@alias uv.spawn.options.stdio.stream uv.uv_stream_t
+
+
+--- The `options.stdio` entries can take many shapes.
+---
+---   - If they are numbers, then the child process inherits that same zero-indexed fd from the parent process.
+---   - If `uv_stream_t` handles are passed in, those are used as a read-write pipe or inherited stream depending if the stream has a valid fd.
+---   - Including `nil` placeholders means to ignore that fd in the child process.
+---
+---@alias uv.spawn.options.stdio
+---| integer
+---| uv.uv_stream_t
+---| nil
+
+
+---@class uv.spawn.options : table
+---
+--- Command line arguments as a list of strings. The first string should be the path to the program. On Windows, this uses CreateProcess which concatenates the arguments into a string. This can cause some strange errors. (See `options.verbatim` below for Windows.)
+---@field args string[]
+---
+--- Set environment variables for the new process.
+---@field env table<string, string>
+---
+--- Set the current working directory for the sub-process.
+---@field cwd string
+---
+--- Set the child process' user id.
+---@field uid string
+---
+--- Set the child process' group id.
+---@field gid string
+---
+--- If true, do not wrap any arguments in quotes, or perform any other escaping, when converting the argument list into a command line string. This option is only meaningful on Windows systems. On Unix it is silently ignored.
+---@field verbatim boolean
+---
+--- If true, spawn the child process in a detached state - this will make it a process group leader, and will effectively enable the child to keep running after the parent exits. Note that the child process will still keep the parent's event loop alive unless the parent process calls `uv.unref()` on the child's process handle.
+---@field detached boolean
+---
+--- If true, hide the subprocess console window that would normally be created. This option is only meaningful on Windows systems. On Unix it is silently ignored.
+---@field hide boolean
+---
+--- Set the file descriptors that will be made available to the child process. The convention is that the first entries are stdin, stdout, and stderr. (**Note**: On Windows, file descriptors after the third are available to the child process only if the child processes uses the MSVCRT runtime.)
+---@field stdio { [1]: uv.spawn.options.stdio, [2]: uv.spawn.options.stdio, [3]: uv.spawn.options.stdio }
+
+
+---@class uv.fs_stat.result.time
+---@field sec integer
+---@field nsec integer
+
+---@class uv.fs_stat.result
+---
+---@field dev       integer
+---@field mode      integer
+---@field nlink     integer
+---@field uid       integer
+---@field gid       integer
+---@field rdev      integer
+---@field ino       integer
+---@field size      integer
+---@field blksize   integer
+---@field blocks    integer
+---@field flags     integer
+---@field gen       integer
+---@field atime     uv.fs_stat.result.time
+---@field mtime     uv.fs_stat.result.time
+---@field ctime     uv.fs_stat.result.time
+---@field birthtime uv.fs_stat.result.time
+---@field type      string
+
+
+---@class uv.fs_statfs.result
+---
+---@field type   integer
+---@field bsize  integer
+---@field blocks integer
+---@field bfree  integer
+---@field bavail integer
+---@field files  integer
+---@field ffree  integer
+
+
+
+---@class uv.getaddrinfo.hints : table
+---@field family      string|integer|uv.socket.family
+---@field socktype    string|integer|uv.socket.type
+---@field protocol    string|integer|uv.socket.protocol
+---@field addrconfig  boolean
+---@field v4mapped    boolean
+---@field all         boolean
+---@field numerichost boolean
+---@field passive     boolean
+---@field numericserv boolean
+---@field canonname   boolean
+
+
+--- uv.getnameinfo.address
+---
+---@class uv.getnameinfo.address : table
+---@field ip     string
+---@field port   integer
+---@field family string|integer
+
+
+--- uv.new_thread.options
+---
+---@class uv.new_thread.options : table
+---@field stack_size integer
+
+
+--- uv.pipe.read_flags
+---
+---@class uv.pipe.read_flags : table
+---@field nonblock boolean|false
+
+
+--- uv.pipe.write_flags
+---
+---@class uv.pipe.write_flags : table
+---@field nonblock boolean|false
+
+---@alias uv.socketpair.fds { [1]: integer, [2]: integer }
+
+--- uv.socketpair.flags
+---
+---@class uv.socketpair.flags : table
+---
+--- Opens the specified socket handle for `OVERLAPPED` or `FIONBIO`/`O_NONBLOCK` I/O usage. This is recommended for handles that will be used by libuv, and not usually recommended otherwise.
+---@field nonblock true|false
+
+---@alias uv.socket.protocol
+---| string
+---| "ip"
+---| "icmp"
+---| "tcp"
+---| "udp"
+
+---@alias uv.socket.type
+---| "stream"
+---| "dgram"
+---| "raw"
+---| "rdm"
+---| "seqpacket"
+
+--- When `protocol` is set to 0 or nil, it will be automatically chosen based on the socket's domain and type.
+---
+--- When `protocol` is specified as a string, it will be looked up using the `getprotobyname(3)` function (examples: `"ip"`, `"icmp"`, `"tcp"`, `"udp"`, etc).
+---
+---@alias uv.socketpair.protocol
+---| 0   # automatically choose based on socket domain/type
+---| nil # automatically choose based on socket domain/type
+---| uv.socket.protocol
+
+---@alias uv.socketpair.socktype
+---| uv.socket.type
+---| integer
+---| nil
+
+--- uv.tcp_bind.flags
+---
+---@class uv.tcp_bind.flags : table
+---@field ipv6only boolean
+
+
+--- uv.udp_bind.flags
+---
+---
+---@class uv.udp_bind.flags : table
+---@field ipv6only boolean
+---@field reuseaddr boolean
+
+--- TTY mode is a C enum with the following values:
+---
+---@alias uv.tty.mode
+---| 0 # UV_TTY_MODE_NORMAL: Initial/normal terminal mode
+---| 1 # UV_TTY_MODE_RAW: Raw input mode (On Windows, ENABLE_WINDOW_INPUT is also enabled)
+---| 2 # UV_TTY_MODE_IO: Binary-safe I/O mode for IPC (Unix-only)
+
+
+--- uv.run() modes:
+---
+---   - `"default"`: Runs the event loop until there are no more active and
+---   referenced handles or requests. Returns `true` if `uv.stop()` was called and
+---   there are still active handles or requests. Returns `false` in all other
+---   cases.
+---
+---   - `"once"`: Poll for I/O once. Note that this function blocks if there are no
+---   pending callbacks. Returns `false` when done (no active handles or requests
+---   left), or `true` if more callbacks are expected (meaning you should run the
+---   event loop again sometime in the future).
+---
+---   - `"nowait"`: Poll for I/O once but don't block if there are no pending
+---   callbacks. Returns `false` if done (no active handles or requests left),
+---   or `true` if more callbacks are expected (meaning you should run the event
+---   loop again sometime in the future).
+---
+---@alias uv.run.mode
+---| "default" # Runs the event loop until there are no more active and referenced handles or requests.
+---| "once" # Poll for I/O once.
+---| "nowait" # Poll for I/O once but don't block if there are no pending callbacks.
+
+
+---@class uv.interface_addresses.addr
+---
+---@field ip       string
+---@field family   string
+---@field netmask  string
+---@field internal boolean
+---@field mac      string
+
+---@class uv.new_udp.flags
+---
+--- When specified, `mmsgs` determines the number of messages able to be received at one time via `recvmmsg(2)` (the allocated buffer will be sized to be able to fit the specified number of max size dgrams). Only has an effect on platforms that support `recvmmsg(2)`.
+---@field mmsgs integer|nil # default `1`
+---
+---@field family uv.new_udp.flags.family|nil
+
+---@alias uv.new_udp.flags.family uv.socket.family
+
+---@alias uv.socket.family
+---| "unix"
+---| "inet"
+---| "inet6"
+---| "ipx"
+---| "netlink"
+---| "x25"
+---| "ax25"
+---| "atmpvc"
+---| "appletalk"
+---| "packet"
+
+
+---@class uv.os_get_passwd.info
+---@field username string
+---@field uid integer
+---@field gid integer
+---@field shell string
+---@field homedir string
+
+---@class uv.os_uname.info
+---@field sysname string
+---@field release string
+---@field version string
+---@field machine string
+
+---@alias uv.pipe_chmod.flags
+---| "r"
+---| "rw"
+---| "w"
+---| "wr"
+
+--- `r` is `READABLE`
+--- `w` is `WRITABLE`
+--- `d` is `DISCONNECT`
+--- `p` is `PRIORITIZED`
+---
+---@alias uv.poll.eventspec
+---| "r"
+---| "rd"
+---| "rw"
+---| "rp"
+---| "rdp"
+---| "rwd"
+---| "rwp"
+---| "rwdp"
+---| "d"
+---| "dp"
+---| "w"
+---| "wd"
+---| "wp"
+---| "wdp"
+---| "p"
+
+
+
+--- socket info
+---
+---@class uv.socketinfo : table
+---@field ip string
+---@field family string|uv.socket.family
+---@field port integer
+
+
+--- uv.udp.sockname
+---
+---@alias uv.udp.sockname uv.socketinfo
+
+
+---@class uv.uv_fs_t          : uv.uv_req_t
+---@class uv.uv_write_t       : uv.uv_req_t
+---@class uv.uv_connect_t     : uv.uv_req_t
+---@class uv.uv_shutdown_t    : uv.uv_req_t
+---@class uv.uv_udp_send_t    : uv.uv_req_t
+---@class uv.uv_getaddrinfo_t : uv.uv_req_t
+---@class uv.uv_getnameinfo_t : uv.uv_req_t
+---@class uv.uv_work_t        : uv.uv_req_t
+
+---@class uv.pipe.fds
+---@field read integer
+---@field write integer
+
+---@class uv.fs_copyfile.flags_t : table
+---@field excl          boolean
+---@field ficlone       boolean
+---@field ficlone_force boolean
+
+---@alias uv.fs_copyfile.flags
+---| uv.fs_copyfile.flags_t
+---| integer
+
+
+---@class uv.fs_event_start.flags : table
+---@field watch_entry boolean|nil # default: false
+---@field stat        boolean|nil # default: false
+---@field recursive   boolean|nil # default: false
+
+---@class uv.fs_event_start.callback.events : table
+---@field change boolean|nil
+---@field rename boolean|nil
+
+--- Event loop
+---
+--- The event loop is the central part of libuv's functionality. It takes care of
+--- polling for I/O and scheduling callbacks to be run based on different sources of
+--- events.
+---
+--- In luv, there is an implicit uv loop for every Lua state that loads the library.
+--- You can use this library in an multi-threaded environment as long as each thread
+--- has it's own Lua state with its corresponding own uv loop. This loop is not
+--- directly exposed to users in the Lua module.
+---
+---@class uv.uv_loop_t : table
+
+---@alias uv.threadargs any
+
+--- Luv APIS that accept a "buffer" type will accept either a string or an array-like table of strings
+---@alias uv.buffer string|string[]
+
+---@alias uv.fs_mkdtemp.callback           fun(err: uv.callback.err, path?:string)
+---@alias uv.fs_access.callback            fun(err: uv.callback.err, permission?:boolean)
+---@alias uv.fs_event_start.callback       fun(err: uv.callback.err, filename:string, events:uv.fs_event_start.callback.events)
+---@alias uv.fs_poll_start.callback        fun(err: uv.callback.err, prev:uv.fs_stat.result|nil, curr:uv.fs_stat.result|nil)
+---@alias uv.fs_fstat.callback             fun(err: uv.callback.err, stat:uv.fs_stat.result|nil)
+---@alias uv.fs_lstat.callback             fun(err: uv.callback.err, stat:uv.fs_stat.result|nil)
+---@alias uv.fs_mkstemp.callback           fun(err: uv.callback.err, fd?:integer, path?:string)
+---@alias uv.fs_opendir.callback           fun(err: uv.callback.err, dir?:uv.luv_dir_t)
+---@alias uv.fs_open.callback              fun(err: uv.callback.err, fd?:integer)
+---@alias uv.fs_read.callback              fun(err: uv.callback.err, data?:string)
+---@alias uv.fs_scandir.callback           fun(err: uv.callback.err, success?:uv.uv_fs_t)
+---@alias uv.fs_sendfile.callback          fun(err: uv.callback.err, bytes?:integer)
+---@alias uv.fs_stat.callback              fun(err: uv.callback.err, stat: uv.fs_stat.result|nil)
+---@alias uv.getaddrinfo.callback          fun(err: uv.callback.err, addresses:uv.getaddrinfo.result[]|nil)
+---@alias uv.getnameinfo.callback          fun(err: uv.callback.err, host?:string, service?:string)
+---@alias uv.fs_write.callback             fun(err: uv.callback.err, bytes?:integer)
+---@alias uv.new_async.callback            fun(...:uv.threadargs)
+---@alias uv.new_work.after_work_callback  fun(...:uv.threadargs)
+---@alias uv.new_work.work_callback        fun(...:uv.threadargs)
+---@alias uv.poll_start.callback           fun(err: uv.callback.err, events?:string)
+---@alias uv.random.callback               fun(err: uv.callback.err, bytes?:string)
+---@alias uv.read_start.callback           fun(err: uv.callback.err, data?:string)
+---@alias uv.signal_start.callback         fun(signum:string)
+---@alias uv.signal_start_oneshot.callback fun(signum:string)
+---@alias uv.spawn.on_exit                 fun(code:integer, signal:integer)
+---@alias uv.fs_readlink.callback          fun(err: uv.callback.err, path?:string)
+---@alias uv.fs_realpath.callback          fun(err: uv.callback.err, path?:string)
+---@alias uv.fs_readdir.callback           fun(err: uv.callback.err, entries: uv.fs_readdir.entry[]|nil)
+
+
+---@class uv.fs_readdir.entry : table
+---@field name string
+---@field type string
+
+
+---@class uv.udp_recv_start.callback.addr : table
+---@field ip string
+---@field port integer
+---@field family uv.socket.family|string
+
+---@class uv.udp_recv_start.callback.flags : table
+---@field partial boolean|nil
+---@field mmsg_chunk boolean|nil
+
+---@alias uv.udp_recv_start.callback fun(err:string|nil, data:string|nil, addr:uv.udp_recv_start.callback.addr|nil, flags:uv.udp_recv_start.callback.flags)
+
+---@alias uv.walk.callback fun(handle:uv.uv_handle_t)
+
+---@alias uv.fs_statfs.callback    fun(err: uv.callback.err, stat: uv.fs_statfs.result|nil)
+
+---@alias uv.pipe_connect.callback uv.callback
+---@alias uv.shutdown.callback     uv.callback
+---@alias uv.tcp_connect.callback  uv.callback
+---@alias uv.udp_send.callback     uv.callback
+---@alias uv.write.callback        uv.callback
+---@alias uv.write2.callback       uv.callback
+---@alias uv.listen.callback       uv.callback
+
+---@alias uv.fs_closedir.callback  uv.callback_with_success
+---@alias uv.fs_copyfile.callback  uv.callback_with_success
+---@alias uv.fs_symlink.callback   uv.callback_with_success
+---@alias uv.fs_unlink.callback    uv.callback_with_success
+---@alias uv.fs_utime.callback     uv.callback_with_success
+---@alias uv.fs_chmod.callback     uv.callback_with_success
+---@alias uv.fs_chown.callback     uv.callback_with_success
+---@alias uv.fs_close.callback     uv.callback_with_success
+---@alias uv.fs_fchmod.callback    uv.callback_with_success
+---@alias uv.fs_fchown.callback    uv.callback_with_success
+---@alias uv.fs_fdatasync.callback uv.callback_with_success
+---@alias uv.fs_fsync.callback     uv.callback_with_success
+---@alias uv.fs_ftruncate.callback uv.callback_with_success
+---@alias uv.fs_futime.callback    uv.callback_with_success
+---@alias uv.fs_lchown.callback    uv.callback_with_success
+---@alias uv.fs_link.callback      uv.callback_with_success
+---@alias uv.fs_lutime.callback    uv.callback_with_success
+---@alias uv.fs_mkdir.callback     uv.callback_with_success
+---@alias uv.fs_rename.callback    uv.callback_with_success
+---@alias uv.fs_rmdir.callback     uv.callback_with_success
+
+---@class uv.fs_symlink.flags : table
+---@field dir boolean
+---@field junction boolean
+
+---@class uv.getaddrinfo.result : table
+---
+---@field addr      string
+---@field family    uv.socket.family|string
+---@field port      integer|nil
+---@field socktype  string
+---@field protocol  string
+---@field canonname string|nil
+
+---@alias uv.callback.err string|nil
+
+---@alias uv.callback.success boolean|nil
+
+---@alias uv.callback fun(err: uv.callback.err)
+
+---@alias uv.callback_with_success fun(err: uv.callback.err, success: uv.callback.success)
+
+
+---@alias uv.fs_open.flags string
+---| "r"
+---| "rs"
+---| "sr"
+---| "r+"
+---| "rs+"
+---| "sr+"
+---| "w"
+---| "wx"
+---| "xw"
+---| "w+"
+---| "wx+"
+---| "xw+"
+---| "a"
+---| "ax"
+---| "xa"
+---| "a+"
+---| "ax+"
+---| "xa+"
+---| integer
+
+
+---@class uv.cpu_info.cpu : table
+---@field model string
+---@field speed number
+---@field times uv.cpu_info.cpu.times
+
+---@class uv.cpu_info.cpu.times : table
+---@field user number
+---@field nice number
+---@field sys  number
+---@field idle number
+---@field irq  number
+
+
+--- The name of the struct for a given request (e.g. `"fs"` for `uv_fs_t`)
+--- and the libuv enum integer for the request's type (`uv_req_type`).
+---
+---@alias uv.req_type.name
+---| "async"
+---| "check"
+---| "fs_event"
+---| "fs_poll"
+---| "handle"
+---| "idle"
+---| "pipe"
+---| "poll"
+---| "prepare"
+---| "process"
+---| "req"
+---| "signal"
+---| "stream"
+---| "tcp"
+---| "timer"
+---| "tty"
+---| "udp"
+
+
+--- The libuv enum integer for the request's type (`uv_req_type`).
+---@alias uv.req_type.enum integer
diff --git a/meta/3rd/luv/library/uv.lua b/meta/3rd/luv/library/uv.lua
new file mode 100644
index 00000000..bce0c22f
--- /dev/null
+++ b/meta/3rd/luv/library/uv.lua
@@ -0,0 +1,3075 @@
+---@meta
+
+--- The luv project provides access to the multi-platform support library
+--- libuv in Lua code. It was primarily developed for the luvit project as
+--- the built-in `uv` module, but can be used in other Lua environments.
+---
+--- More information about the core libuv library can be found at the original
+--- libuv documentation page.
+---
+---
+--- Here is a small example showing a TCP echo server:
+---
+--- ```lua
+--- local uv = require("luv") -- "luv" when stand-alone, "uv" in luvi apps
+---
+--- local server = uv.new_tcp()
+--- server:bind("127.0.0.1", 1337)
+--- server:listen(128, function (err)
+---   assert(not err, err)
+---   local client = uv.new_tcp()
+---   server:accept(client)
+---   client:read_start(function (err, chunk)
+---     assert(not err, err)
+---     if chunk then
+---       client:write(chunk)
+---     else
+---       client:shutdown()
+---       client:close()
+---     end
+---   end)
+--- end)
+--- print("TCP server listening at 127.0.0.1 port 1337")
+--- uv.run() -- an explicit run call is necessary outside of luvit
+--- ```
+---
+---
+--- The luv library contains a single Lua module referred to hereafter as `uv` for
+--- simplicity. This module consists mostly of functions with names corresponding to
+--- their original libuv versions. For example, the libuv function `uv_tcp_bind` has
+--- a luv version at `uv.tcp_bind`. Currently, only one non-function field exists:
+--- `uv.constants`, which is a table.
+---
+---
+--- In addition to having simple functions, luv provides an optional method-style
+--- API. For example, `uv.tcp_bind(server, host, port)` can alternatively be called
+--- as `server:bind(host, port)`. Note that the first argument `server` becomes the
+--- object and `tcp_` is removed from the function name. Method forms are
+--- documented below where they exist.
+---
+---
+--- Functions that accept a callback are asynchronous. These functions may
+--- immediately return results to the caller to indicate their initial status, but
+--- their final execution is deferred until at least the next libuv loop iteration.
+--- After completion, their callbacks are executed with any results passed to it.
+---
+--- Functions that do not accept a callback are synchronous. These functions
+--- immediately return their results to the caller.
+---
+--- Some (generally FS and DNS) functions can behave either synchronously or
+--- asynchronously. If a callback is provided to these functions, they behave
+--- asynchronously; if no callback is provided, they behave synchronously.
+---
+---
+--- Some unique types are defined. These are not actual types in Lua, but they are
+--- used here to facilitate documenting consistent behavior:
+--- - `fail`: an assertable `nil, string, string` tuple (see Error handling)
+--- - `callable`: a `function`; or a `table` or `userdata` with a `__call`
+---   metamethod
+--- - `buffer`: a `string` or a sequential `table` of `string`s
+--- - `threadargs`: variable arguments (`...`) of type `nil`, `boolean`, `number`,
+---   `string`, or `userdata`
+---
+---
+--- This documentation is mostly a retelling of the libuv API documentation
+--- within the context of luv's Lua API. Low-level implementation details and
+--- unexposed C functions and types are not documented here except for when they
+--- are relevant to behavior seen in the Lua module.
+---
+--- [Error handling]: #error-handling
+---
+--- In libuv, errors are negative numbered constants; however, these errors and the
+--- functions used to handle them are not exposed to luv users. Instead, if an
+--- internal error is encountered, the luv function will return to the caller an
+--- assertable `nil, err, name` tuple.
+---
+--- - `nil` idiomatically indicates failure
+--- - `err` is a string with the format `{name}: {message}`
+---   - `{name}` is the error name provided internally by `uv_err_name`
+---   - `{message}` is a human-readable message provided internally by `uv_strerror`
+--- - `name` is the same string used to construct `err`
+---
+--- This tuple is referred to below as the `fail` pseudo-type.
+---
+--- When a function is called successfully, it will return either a value that is
+--- relevant to the operation of the function, or the integer `0` to indicate
+--- success, or sometimes nothing at all. These cases are documented below.
+---
+---
+--- [reference counting]: #reference-counting
+---
+--- The libuv event loop (if run in the default mode) will run until there are no
+--- active and referenced handles left. The user can force the loop to exit early by
+--- unreferencing handles which are active, for example by calling `uv.unref()`
+--- after calling `uv.timer_start()`.
+---
+--- A handle can be referenced or unreferenced, the refcounting scheme doesn't use a
+--- counter, so both operations are idempotent.
+---
+--- All handles are referenced when active by default, see `uv.is_active()` for a
+--- more detailed explanation on what being active involves.
+---
+---
+--- [File system operations]: #file-system-operations
+---
+--- Most file system functions can operate synchronously or asynchronously. When a synchronous version is called (by omitting a callback), the function will
+--- immediately return the results of the FS call. When an asynchronous version is
+--- called (by providing a callback), the function will immediately return a
+--- `uv_fs_t userdata` and asynchronously execute its callback; if an error is encountered, the first and only argument passed to the callback will be the `err` error string; if the operation completes successfully, the first argument will be `nil` and the remaining arguments will be the results of the FS call.
+---
+--- Synchronous and asynchronous versions of `readFile` (with naive error handling)
+--- are implemented below as an example:
+---
+--- ```lua
+--- local function readFileSync(path)
+---   local fd = assert(uv.fs_open(path, "r", 438))
+---   local stat = assert(uv.fs_fstat(fd))
+---   local data = assert(uv.fs_read(fd, stat.size, 0))
+---   assert(uv.fs_close(fd))
+---   return data
+--- end
+---
+--- local data = readFileSync("main.lua")
+--- print("synchronous read", data)
+--- ```
+---
+--- ```lua
+--- local function readFile(path, callback)
+---   uv.fs_open(path, "r", 438, function(err, fd)
+---     assert(not err, err)
+---     uv.fs_fstat(fd, function(err, stat)
+---       assert(not err, err)
+---       uv.fs_read(fd, stat.size, 0, function(err, data)
+---         assert(not err, err)
+---         uv.fs_close(fd, function(err)
+---           assert(not err, err)
+---           return callback(data)
+---         end)
+---       end)
+---     end)
+---   end)
+--- end
+---
+--- readFile("main.lua", function(data)
+---   print("asynchronous read", data)
+--- end)
+--- ```
+---
+---
+--- [Thread pool work scheduling]: #thread-pool-work-scheduling
+---
+--- Libuv provides a threadpool which can be used to run user code and get notified
+--- in the loop thread. This threadpool is internally used to run all file system
+--- operations, as well as `getaddrinfo` and `getnameinfo` requests.
+---
+--- ```lua
+--- local function work_callback(a, b)
+---   return a + b
+--- end
+---
+--- local function after_work_callback(c)
+---   print("The result is: " .. c)
+--- end
+---
+--- local work = uv.new_work(work_callback, after_work_callback)
+---
+--- work:queue(1, 2)
+---
+--- -- output: "The result is: 3"
+--- ```
+---
+---
+--- [DNS utility functions]: #dns-utility-functions
+---
+---
+--- [Threading and synchronization utilities]: #threading-and-synchronization-utilities
+---
+--- Libuv provides cross-platform implementations for multiple threading an
+---  synchronization primitives. The API largely follows the pthreads API.
+---
+---
+--- [Miscellaneous utilities]: #miscellaneous-utilities
+---
+---
+--- [Metrics operations]: #metrics-operations
+---
+---@class uv
+---
+---@field errno uv.errno
+---
+local uv
+
+
+--- This call is used in conjunction with `uv.listen()` to accept incoming
+--- connections. Call this function after receiving a callback to accept the
+--- connection.
+---
+--- When the connection callback is called it is guaranteed that this function
+--- will complete successfully the first time. If you attempt to use it more than
+--- once, it may fail. It is suggested to only call this function once per
+--- connection call.
+---
+--- ```lua
+--- server:listen(128, function (err)
+---   local client = uv.new_tcp()
+---   server:accept(client)
+--- end)
+--- ```
+---
+---@param  stream        uv.uv_stream_t
+---@param  client_stream uv.uv_stream_t
+---@return 0|nil         success
+---@return uv.error.message|nil    err
+---@return uv.error.name|nil    err_name
+function uv.accept(stream, client_stream) end
+
+
+--- Wakeup the event loop and call the async handle's callback.
+---
+--- **Note**: It's safe to call this function from any thread. The callback will be
+--- called on the loop thread.
+---
+--- **Warning**: libuv will coalesce calls to `uv.async_send(async)`, that is, not
+--- every call to it will yield an execution of the callback. For example: if
+--- `uv.async_send()` is called 5 times in a row before the callback is called, the
+--- callback will only be called once. If `uv.async_send()` is called again after
+--- the callback was called, it will be called again.
+---
+---@param  async      uv.uv_async_t
+---@param  ...        uv.threadargs
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.async_send(async, ...) end
+
+
+
+--- Returns an estimate of the default amount of parallelism a program should use. Always returns a non-zero value.
+---
+--- On Linux, inspects the calling thread’s CPU affinity mask to determine if it has been pinned to specific CPUs.
+---
+--- On Windows, the available parallelism may be underreported on systems with more than 64 logical CPUs.
+---
+--- On other platforms, reports the number of CPUs that the operating system considers to be online.
+---
+---@return integer
+function uv.available_parallelism() end
+
+
+
+--- Get backend file descriptor. Only kqueue, epoll, and event ports are supported.
+---
+--- This can be used in conjunction with `uv.run("nowait")` to poll in one thread
+--- and run the event loop's callbacks in another
+---
+--- **Note**: Embedding a kqueue fd in another kqueue pollset doesn't work on all
+--- platforms. It's not an error to add the fd but it never generates events.
+---
+---@return integer|nil fd
+function uv.backend_fd() end
+
+
+
+--- Get the poll timeout. The return value is in milliseconds, or -1 for no timeout.
+---
+---@return integer
+function uv.backend_timeout() end
+
+
+--- Cancel a pending request. Fails if the request is executing or has finished
+--- executing. Only cancellation of `uv_fs_t`, `uv_getaddrinfo_t`,
+--- `uv_getnameinfo_t` and `uv_work_t` requests is currently supported.
+---
+---@param  req        uv.uv_req_t
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.cancel(req) end
+
+
+
+--- Sets the current working directory with the string `cwd`.
+---
+---@param  cwd        string
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.chdir(cwd) end
+
+
+--- Start the handle with the given callback.
+---
+---@param  check      uv.uv_check_t
+---@param  callback   function
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.check_start(check, callback) end
+
+
+--- Stop the handle, the callback will no longer be called.
+---
+---@param  check      uv.uv_check_t
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.check_stop(check) end
+
+
+--- Request handle to be closed. `callback` will be called asynchronously after this
+--- call. This MUST be called on each handle before memory is released.
+---
+--- Handles that wrap file descriptors are closed immediately but `callback` will
+--- still be deferred to the next iteration of the event loop. It gives you a chance
+--- to free up any resources associated with the handle.
+---
+--- In-progress requests, like `uv_connect_t` or `uv_write_t`, are cancelled and
+--- have their callbacks called asynchronously with `ECANCELED`.
+---
+---@param handle uv.uv_handle_t
+---@param callback? function
+function uv.close(handle, callback) end
+
+
+
+--- Returns information about the CPU(s) on the system as a table of tables for each
+--- CPU found.
+---
+--- **Returns:** `table` or `fail`
+--- - `[1, 2, 3, ..., n]` : `table`
+---   - `model` : `string`
+---   - `speed` : `number`
+---   - `times` : `table`
+---     - `user` : `number`
+---     - `nice` : `number`
+---     - `sys` : `number`
+---     - `idle` : `number`
+---     - `irq` : `number`
+---
+---@return uv.cpu_info.cpu[]|nil info
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.cpu_info() end
+
+
+
+--- Returns the current working directory.
+---
+---@return string|nil cwd
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.cwd() end
+
+
+
+--- Disables inheritance for file descriptors / handles that this process inherited
+--- from its parent. The effect is that child processes spawned by this process
+--- don't accidentally inherit these handles.
+---
+--- It is recommended to call this function as early in your program as possible,
+--- before the inherited file descriptors can be closed or duplicated.
+---
+--- **Note:** This function works on a best-effort basis: there is no guarantee that
+--- libuv can discover all file descriptors that were inherited. In general it does
+--- a better job on Windows than it does on Unix.
+function uv.disable_stdio_inheritance() end
+
+
+
+--- Returns the executable path.
+---
+---@return string|nil exepath
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.exepath() end
+
+
+--- Gets the platform dependent file descriptor equivalent.
+---
+--- The following handles are supported: TCP, pipes, TTY, UDP and poll. Passing any
+--- other handle type will fail with `EINVAL`.
+---
+--- If a handle doesn't have an attached file descriptor yet or the handle itself
+--- has been closed, this function will return `EBADF`.
+---
+--- **Warning**: Be very careful when using this function. libuv assumes it's in
+--- control of the file descriptor so any change to it may lead to malfunction.
+---
+---@param  handle      uv.uv_handle_t
+---@return integer|nil fileno
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.fileno(handle) end
+
+
+
+--- Equivalent to `access(2)` on Unix. Windows uses `GetFileAttributesW()`. Access
+--- `mode` can be an integer or a string containing `"R"` or `"W"` or `"X"`.
+--- Returns `true` or `false` indicating access permission.
+---
+---@param  path        string
+---@param  mode        integer|string
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(path:string, mode:integer|string, callback:uv.fs_access.callback):uv.uv_fs_t
+function uv.fs_access(path, mode) end
+
+
+
+--- Equivalent to `chmod(2)`.
+---
+---@param  path        string
+---@param  mode        integer
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(path:string, mode:integer, callback:uv.fs_chmod.callback):uv.uv_fs_t
+function uv.fs_chmod(path, mode) end
+
+
+
+--- Equivalent to `chown(2)`.
+---
+---@param  path        string
+---@param  uid         integer
+---@param  gid         integer
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(path:string, uid:integer, gid:integer, callback:uv.fs_chown.callback):uv.uv_fs_t
+function uv.fs_chown(path, uid, gid) end
+
+
+
+--- Equivalent to `close(2)`.
+---
+---@param  fd          integer
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(fd:integer, callback:uv.fs_close.callback):uv.uv_fs_t
+function uv.fs_close(fd) end
+
+
+--- Closes a directory stream returned by a successful `uv.fs_opendir()` call.
+---
+---@param  dir         uv.luv_dir_t
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(dir:uv.luv_dir_t, callback:uv.fs_closedir.callback):uv.uv_fs_t
+function uv.fs_closedir(dir) end
+
+
+
+--- Copies a file from path to new_path. If the `flags` parameter is omitted, then the 3rd parameter will be treated as the `callback`.
+---
+--- **Returns (sync version):** `boolean` or `fail`
+---
+--- **Returns (async version):** `uv_fs_t userdata`
+---
+---@param  path        string
+---@param  new_path    string
+---@param  flags?      uv.fs_copyfile.flags
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(path:string, new_path:string, flags?:uv.fs_copyfile.flags, callback:uv.fs_copyfile.callback):uv.uv_fs_t
+---@overload fun(path:string, new_path:string, callback:uv.fs_copyfile.callback):uv.uv_fs_t
+function uv.fs_copyfile(path, new_path, flags) end
+
+
+--- Get the path being monitored by the handle.
+---
+---@param  fs_event   uv.uv_fs_event_t
+---@return string|nil path
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.fs_event_getpath(fs_event) end
+
+
+--- Start the handle with the given callback, which will watch the specified path
+--- for changes.
+---
+---@param  fs_event   uv.uv_fs_event_t
+---@param  path       string
+---@param  flags      uv.fs_event_start.flags
+---@param  callback   uv.fs_event_start.callback
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.fs_event_start(fs_event, path, flags, callback) end
+
+
+--- Stop the handle, the callback will no longer be called.
+---
+---@param  fs_event   uv.uv_fs_event_t
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.fs_event_stop(fs_event) end
+
+
+
+--- Equivalent to `fchmod(2)`.
+---
+---@param  fd          integer
+---@param  mode        integer
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(fd:integer, mode:integer, callback:uv.fs_fchmod.callback):uv.uv_fs_t
+function uv.fs_fchmod(fd, mode) end
+
+
+
+--- Equivalent to `fchown(2)`.
+---
+---@param  fd          integer
+---@param  uid         integer
+---@param  gid         integer
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(fd:integer, uid:integer, gid:integer, callback:uv.fs_fchown.callback):uv.uv_fs_t
+function uv.fs_fchown(fd, uid, gid) end
+
+
+
+--- Equivalent to `fdatasync(2)`.
+---
+---@param  fd          integer
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(fd:integer, callback:uv.fs_fdatasync.callback):uv.uv_fs_t
+function uv.fs_fdatasync(fd) end
+
+
+
+--- Equivalent to `fstat(2)`.
+---
+--- **Returns (sync version):** `table` or `fail` (see `uv.fs_stat`)
+---
+--- **Returns (async version):** `uv_fs_t userdata`
+---
+---@param  fd                    integer
+---@return uv.fs_stat.result|nil stat
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(fd:integer, callback:uv.fs_fstat.callback):uv.uv_fs_t
+function uv.fs_fstat(fd) end
+
+
+
+--- Equivalent to `fsync(2)`.
+---
+---@param  fd          integer
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(fd:integer, callback:uv.fs_fsync.callback):uv.uv_fs_t
+function uv.fs_fsync(fd) end
+
+
+
+--- Equivalent to `ftruncate(2)`.
+---
+---@param  fd          integer
+---@param  offset      integer
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(fd:integer, offset:integer, callback:uv.fs_ftruncate.callback):uv.uv_fs_t
+function uv.fs_ftruncate(fd, offset) end
+
+
+
+--- Equivalent to `futime(2)`.
+---
+---@param  fd          integer
+---@param  atime       number
+---@param  mtime       number
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(fd:integer, atime:number, mtime:number, callback:uv.fs_futime.callback):uv.uv_fs_t
+function uv.fs_futime(fd, atime, mtime) end
+
+
+
+--- Equivalent to `lchown(2)`.
+---
+---@param  fd          integer
+---@param  uid         integer
+---@param  gid         integer
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(fd:integer, uid:integer, gid:integer, callback:uv.fs_lchown.callback):uv.uv_fs_t
+function uv.fs_lchown(fd, uid, gid) end
+
+
+
+--- Equivalent to `link(2)`.
+---
+--- **Returns (sync version):** `boolean` or `fail`
+---
+--- **Returns (async version):** `uv_fs_t userdata`
+---
+---@param  path        string
+---@param  new_path    string
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(path:string, new_path:string, callback:uv.fs_link.callback):uv.uv_fs_t
+function uv.fs_link(path, new_path) end
+
+
+
+--- Equivalent to `lstat(2)`.
+---
+--- **Returns (sync version):** `table` or `fail` (see `uv.fs_stat`)
+---
+--- **Returns (async version):** `uv_fs_t userdata`
+---
+---@param  path                  integer
+---@return uv.fs_stat.result|nil stat
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(path:integer, callback:uv.fs_lstat.callback):uv.uv_fs_t
+function uv.fs_lstat(path) end
+
+
+
+--- Equivalent to `lutime(2)`.
+---
+---@param  path        string
+---@param  atime       number
+---@param  mtime       number
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(path:string, atime:number, mtime:number, callback:uv.fs_lutime.callback):uv.uv_fs_t
+function uv.fs_lutime(path, atime, mtime) end
+
+
+
+--- Equivalent to `mkdir(2)`.
+---
+---@param  path        string
+---@param  mode        integer
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(path:string, mode:integer, callback:uv.fs_mkdir.callback):uv.uv_fs_t
+function uv.fs_mkdir(path, mode) end
+
+
+
+--- Equivalent to `mkdtemp(3)`.
+---
+---@param  template   string
+---@return string|nil path
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(template:string, callback:uv.fs_mkdtemp.callback):uv.uv_fs_t
+function uv.fs_mkdtemp(template) end
+
+
+
+--- Equivalent to `mkstemp(3)`. Returns a temporary file handle and filename.
+---
+---@param  template    string
+---@return integer|nil fd
+---@return string      path_or_errmsg
+---@return uv.error.name|nil err_name
+---
+---@overload fun(template:string, callback:uv.fs_mkstemp.callback):uv.uv_fs_t
+function uv.fs_mkstemp(template) end
+
+
+
+--- Equivalent to `open(2)`. Access `flags` may be an integer or one of: `"r"`,
+--- `"rs"`, `"sr"`, `"r+"`, `"rs+"`, `"sr+"`, `"w"`, `"wx"`, `"xw"`, `"w+"`,
+--- `"wx+"`, `"xw+"`, `"a"`, `"ax"`, `"xa"`, `"a+"`, `"ax+"`, or "`xa+`".
+---
+--- **Returns (sync version):** `integer` or `fail`
+---
+--- **Returns (async version):** `uv_fs_t userdata`
+---
+--- **Note:** On Windows, libuv uses `CreateFileW` and thus the file is always
+--- opened in binary mode. Because of this, the `O_BINARY` and `O_TEXT` flags are
+--- not supported.
+---
+---@param  path        string
+---@param  flags       uv.fs_open.flags
+---@param  mode        integer
+---@return integer|nil fd
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(path:string, flags:uv.fs_open.flags, mode:integer, callback:uv.fs_open.callback):uv.uv_fs_t
+function uv.fs_open(path, flags, mode) end
+
+
+
+--- Opens path as a directory stream. Returns a handle that the user can pass to
+--- `uv.fs_readdir()`. The `entries` parameter defines the maximum number of entries
+--- that should be returned by each call to `uv.fs_readdir()`.
+---
+--- **Returns (sync version):** `luv_dir_t userdata` or `fail`
+---
+--- **Returns (async version):** `uv_fs_t userdata`
+---
+---@param  path             string
+---@return uv.luv_dir_t|nil dir
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(path: string, callback: uv.fs_opendir.callback, entries?: integer):uv.uv_fs_t
+function uv.fs_opendir(path) end
+
+
+--- Get the path being monitored by the handle.
+---
+---@param  fs_poll    uv.uv_fs_poll_t
+---@return string|nil path
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.fs_poll_getpath(fs_poll) end
+
+
+--- Check the file at `path` for changes every `interval` milliseconds.
+---
+--- **Note:** For maximum portability, use multi-second intervals. Sub-second
+--- intervals will not detect all changes on many file systems.
+---
+---@param  fs_poll    uv.uv_fs_poll_t
+---@param  path       string
+---@param  interval   integer
+---@param  callback   uv.fs_poll_start.callback
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.fs_poll_start(fs_poll, path, interval, callback) end
+
+
+--- Stop the handle, the callback will no longer be called.
+---
+---@param fs_poll uv.uv_fs_poll_t
+---@return 0|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.fs_poll_stop(fs_poll) end
+
+
+
+--- Equivalent to `preadv(2)`. Returns any data. An empty string indicates EOF.
+---
+--- If `offset` is nil or omitted, it will default to `-1`, which indicates 'use and update the current file offset.'
+---
+--- **Note:** When `offset` is >= 0, the current file offset will not be updated by the read.
+---
+---@param  fd         integer
+---@param  size       integer
+---@param  offset?    integer
+---@return string|nil data
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(fd:integer, size:integer, offset?:integer, callback:uv.fs_read.callback):uv.uv_fs_t
+function uv.fs_read(fd, size, offset) end
+
+
+--- Iterates over the directory stream `luv_dir_t` returned by a successful
+--- `uv.fs_opendir()` call. A table of data tables is returned where the number
+--- of entries `n` is equal to or less than the `entries` parameter used in
+--- the associated `uv.fs_opendir()` call.
+---
+---@param  dir                       uv.luv_dir_t
+---@return uv.fs_readdir.entry[]|nil entries
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(dir:uv.luv_dir_t, callback:uv.fs_readdir.callback):uv.uv_fs_t
+function uv.fs_readdir(dir) end
+
+
+
+--- Equivalent to `readlink(2)`.
+---
+---@param  path       string
+---@return string|nil path
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(path:string, callback:uv.fs_readlink.callback):uv.uv_fs_t
+function uv.fs_readlink(path) end
+
+
+
+--- Equivalent to `realpath(3)`.
+---
+---@param  path       string
+---@return string|nil realpath
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(path:string, callback:uv.fs_realpath.callback):uv.uv_fs_t
+function uv.fs_realpath(path) end
+
+
+
+--- Equivalent to `rename(2)`.
+---
+---@param  path        string
+---@param  new_path    string
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(path:string, new_path:string, callback:uv.fs_rename.callback):uv.uv_fs_t
+function uv.fs_rename(path, new_path) end
+
+
+
+--- Equivalent to `rmdir(2)`.
+---
+---@param  path        string
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(path:string, callback:uv.fs_rmdir.callback):uv.uv_fs_t
+function uv.fs_rmdir(path) end
+
+
+
+--- Equivalent to `scandir(3)`, with a slightly different API. Returns a handle that
+--- the user can pass to `uv.fs_scandir_next()`.
+---
+--- **Note:** This function can be used synchronously or asynchronously. The request
+--- userdata is always synchronously returned regardless of whether a callback is
+--- provided and the same userdata is passed to the callback if it is provided.
+---
+---@param  path           string
+---@param  callback?      uv.fs_scandir.callback
+---@return uv.uv_fs_t|nil fs
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.fs_scandir(path, callback) end
+
+
+
+--- Called on a `uv_fs_t` returned by `uv.fs_scandir()` to get the next directory
+--- entry data as a `name, type` pair. When there are no more entries, `nil` is
+--- returned.
+---
+--- **Note:** This function only has a synchronous version. See `uv.fs_opendir` and
+--- its related functions for an asynchronous version.
+---
+---@param  fs         uv.uv_fs_t
+---@return string|nil name
+---@return string     type_or_errmsg
+---@return uv.error.name|nil err_name
+function uv.fs_scandir_next(fs) end
+
+
+
+--- Limited equivalent to `sendfile(2)`. Returns the number of bytes written.
+---
+---@param  out_fd      integer
+---@param  in_fd       integer
+---@param  in_offset   integer
+---@param  size        integer
+---@return integer|nil bytes
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(out_fd:integer, in_fd:integer, in_offset:integer, size:integer, callback:uv.fs_sendfile.callback):uv.uv_fs_t
+function uv.fs_sendfile(out_fd, in_fd, in_offset, size) end
+
+
+
+--- Equivalent to `stat(2)`.
+---
+--- **Returns (sync version):** `table` or `fail`
+--- - `dev` : `integer`
+--- - `mode` : `integer`
+--- - `nlink` : `integer`
+--- - `uid` : `integer`
+--- - `gid` : `integer`
+--- - `rdev` : `integer`
+--- - `ino` : `integer`
+--- - `size` : `integer`
+--- - `blksize` : `integer`
+--- - `blocks` : `integer`
+--- - `flags` : `integer`
+--- - `gen` : `integer`
+--- - `atime` : `table`
+---   - `sec` : `integer`
+---   - `nsec` : `integer`
+--- - `mtime` : `table`
+---   - `sec` : `integer`
+---   - `nsec` : `integer`
+--- - `ctime` : `table`
+---   - `sec` : `integer`
+---   - `nsec` : `integer`
+--- - `birthtime` : `table`
+---   - `sec` : `integer`
+---   - `nsec` : `integer`
+--- - `type` : `string`
+---
+--- **Returns (async version):** `uv_fs_t userdata`
+---
+---@param path string
+---@return uv.fs_stat.result|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(path:string, callback:uv.fs_stat.callback):uv.uv_fs_t
+function uv.fs_stat(path) end
+
+
+--- Equivalent to `statfs(2)`.
+---
+--- **Returns** `table` or `nil`
+--- - `type` : `integer`
+--- - `bsize` : `integer`
+--- - `blocks` : `integer`
+--- - `bfree` : `integer`
+--- - `bavail` : `integer`
+--- - `files` : `integer`
+--- - `ffree` : `integer`
+---
+---@param path string
+---@return uv.fs_statfs.result|nil stat
+---
+---@overload fun(path: string, callback: uv.fs_statfs.callback)
+function uv.fs_statfs(path) end
+
+
+
+--- Equivalent to `symlink(2)`. If the `flags` parameter is omitted, then the 3rd parameter will be treated as the `callback`.
+---
+---
+---@param  path        string
+---@param  new_path    string
+---@param  flags?      uv.fs_symlink.flags|integer
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(path:string, new_path:string, flags?:uv.fs_symlink.flags|integer, callback:uv.fs_symlink.callback):uv.uv_fs_t
+---@overload fun(path:string, new_path:string, callback:uv.fs_symlink.callback):uv.uv_fs_t
+function uv.fs_symlink(path, new_path, flags) end
+
+
+
+--- Equivalent to `unlink(2)`.
+---
+---@param  path        string
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(path:string, callback:uv.fs_unlink.callback):uv.uv_fs_t
+function uv.fs_unlink(path) end
+
+
+
+--- Equivalent to `utime(2)`.
+---
+---@param  path        string
+---@param  atime       number
+---@param  mtime       number
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(path:string, atime:number, mtime:number, callback:uv.fs_utime.callback):uv.uv_fs_t
+function uv.fs_utime(path, atime, mtime) end
+
+
+
+--- Equivalent to `pwritev(2)`. Returns the number of bytes written.
+---
+--- If `offset` is nil or omitted, it will default to `-1`, which indicates 'use and update the current file offset.'
+---
+--- **Note:** When `offset` is >= 0, the current file offset will not be updated by the write.
+---
+---@param  fd          integer
+---@param  data        uv.buffer
+---@param  offset?     integer
+---@return integer|nil bytes
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(fd:integer, data:uv.buffer, offset?:integer, callback:uv.fs_write.callback):uv.uv_fs_t
+function uv.fs_write(fd, data, offset) end
+
+
+
+--- Gets the amount of memory available to the process in bytes based on limits
+--- imposed by the OS. If there is no such constraint, or the constraint is unknown,
+--- 0 is returned. Note that it is not unusual for this value to be less than or
+--- greater than the total system memory.
+---
+---@return number
+function uv.get_constrained_memory() end
+
+
+
+--- Returns the current free system memory in bytes.
+---
+---@return number
+function uv.get_free_memory() end
+
+
+
+--- Returns the title of the current process.
+---
+---@return string|nil title
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.get_process_title() end
+
+
+
+--- Returns the current total system memory in bytes.
+---
+--- **Returns:** `number`
+---
+---@return number
+function uv.get_total_memory() end
+
+
+
+--- Equivalent to `getaddrinfo(3)`. Either `node` or `service` may be `nil` but not
+--- both.
+---
+--- Valid hint strings for the keys that take a string:
+--- - `family`: `"unix"`, `"inet"`, `"inet6"`, `"ipx"`,
+--- `"netlink"`, `"x25"`, `"ax25"`, `"atmpvc"`, `"appletalk"`, or `"packet"`
+--- - `socktype`: `"stream"`, `"dgram"`, `"raw"`,
+--- `"rdm"`, or `"seqpacket"`
+--- - `protocol`: will be looked up using the `getprotobyname(3)` function (examples: `"ip"`, `"icmp"`, `"tcp"`, `"udp"`, etc)
+---
+--- **Returns (sync version):** `table` or `fail`
+--- - `[1, 2, 3, ..., n]` : `table`
+---   - `addr` : `string`
+---   - `family` : `string`
+---   - `port` : `integer` or `nil`
+---   - `socktype` : `string`
+---   - `protocol` : `string`
+---   - `canonname` : `string` or `nil`
+---
+--- **Returns (async version):** `uv_getaddrinfo_t userdata` or `fail`
+---
+---@param  host                        string
+---@param  service                     string
+---@param  hints?                      uv.getaddrinfo.hints
+---@return uv.getaddrinfo.result[]|nil info
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(host:string, service:string, hints?:uv.getaddrinfo.hints, callback:uv.getaddrinfo.callback):uv.uv_getaddrinfo_t userdata|nil, string?, string?
+function uv.getaddrinfo(host, service, hints) end
+
+
+
+--- Returns the group ID of the process.
+---
+--- **Note:** This is not a libuv function and is not supported on Windows.
+---
+---@return integer
+function uv.getgid() end
+
+
+
+--- Equivalent to `getnameinfo(3)`.
+---
+--- When specified, `family` must be one of `"unix"`, `"inet"`, `"inet6"`, `"ipx"`,
+--- `"netlink"`, `"x25"`, `"ax25"`, `"atmpvc"`, `"appletalk"`, or `"packet"`.
+---
+--- **Returns (sync version):** `string, string` or `fail`
+---
+--- **Returns (async version):** `uv_getnameinfo_t userdata` or `fail`
+---
+---@param  address    uv.getnameinfo.address
+---@return string|nil host
+---@return string     service_or_errmsg
+---@return uv.error.name|nil err_name
+---
+---@overload fun(address:uv.getnameinfo.address, callback:uv.getnameinfo.callback):uv.uv_getnameinfo_t|nil, string|nil, string|nil
+function uv.getnameinfo(address) end
+
+
+
+--- **Deprecated:** Please use `uv.os_getpid()` instead.
+---
+function uv.getpid() end
+
+
+
+--- Returns the resource usage.
+---
+--- **Returns:** `table` or `fail`
+--- - `utime` : `table` (user CPU time used)
+---   - `sec` : `integer`
+---   - `usec` : `integer`
+--- - `stime` : `table` (system CPU time used)
+---   - `sec` : `integer`
+---   - `usec` : `integer`
+--- - `maxrss` : `integer` (maximum resident set size)
+--- - `ixrss` : `integer` (integral shared memory size)
+--- - `idrss` : `integer` (integral unshared data size)
+--- - `isrss` : `integer` (integral unshared stack size)
+--- - `minflt` : `integer` (page reclaims (soft page faults))
+--- - `majflt` : `integer` (page faults (hard page faults))
+--- - `nswap` : `integer` (swaps)
+--- - `inblock` : `integer` (block input operations)
+--- - `oublock` : `integer` (block output operations)
+--- - `msgsnd` : `integer` (IPC messages sent)
+--- - `msgrcv` : `integer` (IPC messages received)
+--- - `nsignals` : `integer` (signals received)
+--- - `nvcsw` : `integer` (voluntary context switches)
+--- - `nivcsw` : `integer` (involuntary context switches)
+---
+---@return uv.getrusage.result|nil usage
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.getrusage() end
+
+
+
+--- Cross-platform implementation of `gettimeofday(2)`. Returns the seconds and
+--- microseconds of a unix time as a pair.
+---
+---@return integer|nil    seconds
+---@return integer|string usecs_or_errmsg
+---@return uv.error.name|nil err_name
+function uv.gettimeofday() end
+
+
+
+--- Returns the user ID of the process.
+---
+--- **Note:** This is not a libuv function and is not supported on Windows.
+---
+---@return integer
+function uv.getuid() end
+
+
+
+--- Used to detect what type of stream should be used with a given file
+--- descriptor `fd`. Usually this will be used during initialization to guess the
+--- type of the stdio streams.
+---
+---@param fd integer
+---@return string
+function uv.guess_handle(fd) end
+
+
+--- Returns the name of the struct for a given handle (e.g. `"pipe"` for `uv_pipe_t`)
+--- and the libuv enum integer for the handle's type (`uv_handle_type`).
+---
+---@param  handle  uv.uv_handle_t
+---@return string  type
+---@return integer enum
+function uv.handle_get_type(handle) end
+
+
+--- Returns `true` if the handle referenced, `false` if not.
+---
+--- See [Reference counting][].
+---
+---@param  handle      uv.uv_handle_t
+---@return boolean|nil has_ref
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.has_ref(handle) end
+
+
+
+--- Returns a current high-resolution time in nanoseconds as a number. This is
+--- relative to an arbitrary time in the past. It is not related to the time of day
+--- and therefore not subject to clock drift. The primary use is for measuring
+--- time between intervals.
+---
+--- **Returns:** `number`
+---
+---@return number
+function uv.hrtime() end
+
+
+--- Start the handle with the given callback.
+---
+---@param  idle       uv.uv_idle_t
+---@param  callback   function
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.idle_start(idle, callback) end
+
+
+--- Stop the handle, the callback will no longer be called.
+---
+---@param  idle       uv.uv_idle_t
+---@param  check      any
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.idle_stop(idle, check) end
+
+
+
+--- Retrieves a network interface identifier suitable for use in an IPv6 scoped
+--- address. On Windows, returns the numeric `ifindex` as a string. On all other
+--- platforms, `uv.if_indextoname()` is used.
+---
+---@param  ifindex    integer
+---@return string|nil id
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.if_indextoiid(ifindex) end
+
+
+
+--- IPv6-capable implementation of `if_indextoname(3)`.
+---
+---@param  ifindex    integer
+---@return string|nil name
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.if_indextoname(ifindex) end
+
+
+--- Returns address information about the network interfaces on the system in a
+--- table. Each table key is the name of the interface while each associated value
+--- is an array of address information where fields are `ip`, `family`, `netmask`,
+--- `internal`, and `mac`.
+---
+---@return table<string, uv.interface_addresses.addr>
+function uv.interface_addresses() end
+
+
+--- Returns `true` if the handle is active, `false` if it's inactive. What "active”
+--- means depends on the type of handle:
+---
+---   - A [`uv_async_t`][] handle is always active and cannot be deactivated, except
+---   by closing it with `uv.close()`.
+---
+---   - A [`uv_pipe_t`][], [`uv_tcp_t`][], [`uv_udp_t`][], etc. handle - basically
+---   any handle that deals with I/O - is active when it is doing something that
+---   involves I/O, like reading, writing, connecting, accepting new connections,
+---   etc.
+---
+---   - A [`uv_check_t`][], [`uv_idle_t`][], [`uv_timer_t`][], etc. handle is active
+---   when it has been started with a call to `uv.check_start()`, `uv.idle_start()`,
+---   `uv.timer_start()` etc. until it has been stopped with a call to its
+---   respective stop function.
+---
+---@param  handle      uv.uv_handle_t
+---@return boolean|nil active
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.is_active(handle) end
+
+
+--- Returns `true` if the handle is closing or closed, `false` otherwise.
+---
+--- **Note**: This function should only be used between the initialization of the
+--- handle and the arrival of the close callback.
+---
+---@param  handle      uv.uv_handle_t
+---@return boolean|nil closing
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.is_closing(handle) end
+
+
+--- Returns `true` if the stream is readable, `false` otherwise.
+---
+---@param stream uv.uv_stream_t
+---@return boolean
+function uv.is_readable(stream) end
+
+
+--- Returns `true` if the stream is writable, `false` otherwise.
+---
+---@param stream uv.uv_stream_t
+---@return boolean
+function uv.is_writable(stream) end
+
+
+--- Sends the specified signal to the given PID. Check the documentation on
+--- `uv_signal_t` for signal support, specially on Windows.
+---
+---@param  pid        integer
+---@param  signum     integer|string
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.kill(pid, signum) end
+
+
+--- Start listening for incoming connections. `backlog` indicates the number of
+--- connections the kernel might queue, same as `listen(2)`. When a new incoming
+--- connection is received the callback is called.
+---
+--- **Returns:** `0` or `fail`
+---
+---@param  stream     uv.uv_stream_t
+---@param  backlog    integer
+---@param  callback   uv.listen.callback
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.listen(stream, backlog, callback) end
+
+
+--- Returns the load average as a triad. Not supported on Windows.
+---
+---@return number
+---@return number
+---@return number
+function uv.loadavg() end
+
+
+
+--- Returns `true` if there are referenced active handles, active requests, or
+--- closing handles in the loop; otherwise, `false`.
+---
+---@return boolean|nil alive
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.loop_alive() end
+
+
+
+--- Closes all internal loop resources. In normal execution, the loop will
+--- automatically be closed when it is garbage collected by Lua, so it is not
+--- necessary to explicitly call `loop_close()`. Call this function only after the
+--- loop has finished executing and all open handles and requests have been closed,
+--- or it will return `EBUSY`.
+---
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.loop_close() end
+
+
+
+--- Set additional loop options. You should normally call this before the first call
+--- to uv_run() unless mentioned otherwise.
+---
+--- Supported options:
+---
+---   - `"block_signal"`: Block a signal when polling for new events. The second argument
+---   to loop_configure() is the signal name (as a lowercase string) or the signal number.
+---   This operation is currently only implemented for `"sigprof"` signals, to suppress
+---   unnecessary wakeups when using a sampling profiler. Requesting other signals will
+---   fail with `EINVAL`.
+---   - `"metrics_idle_time"`: Accumulate the amount of idle time the event loop spends
+---   in the event provider. This option is necessary to use `metrics_idle_time()`.
+---
+--- An example of a valid call to this function is:
+---
+--- ```lua
+--- uv.loop_configure("block_signal", "sigprof")
+--- ```
+---
+--- **Note:** Be prepared to handle the `ENOSYS` error; it means the loop option is
+--- not supported by the platform.
+---
+---@param  option     "block_signal"
+---@param  value      "sigprof"
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(option: "metrics_idle_time"):(success:0|nil, err:uv.error.message|nil, err_name:uv.error.name|nil)
+function uv.loop_configure(option, value) end
+
+
+--- If the loop is running, returns a string indicating the mode in use. If the loop
+--- is not running, `nil` is returned instead.
+---
+---@return string|nil
+function uv.loop_mode() end
+
+
+--- Retrieve the amount of time the event loop has been idle in the kernel’s event
+--- provider (e.g. `epoll_wait`). The call is thread safe.
+---
+--- The return value is the accumulated time spent idle in the kernel’s event
+--- provider starting from when the [`uv_loop_t`][] was configured to collect the idle time.
+---
+--- **Note:** The event loop will not begin accumulating the event provider’s idle
+--- time until calling `loop_configure` with `"metrics_idle_time"`.
+---
+--- **Returns:** `number`
+---
+--- ---
+---
+--- [luv]: https://github.com/luvit/luv
+--- [luvit]: https://github.com/luvit/luvit
+--- [libuv]: https://github.com/libuv/libuv
+--- [libuv documentation page]: http://docs.libuv.org/
+--- [libuv API documentation]: http://docs.libuv.org/en/v1.x/api.html
+---
+---@return number
+function uv.metrics_idle_time() end
+
+
+--- Creates and initializes a new `uv_async_t`. Returns the Lua userdata wrapping
+--- it. A `nil` callback is allowed.
+---
+--- **Note**: Unlike other handle initialization functions, this immediately starts
+--- the handle.
+---
+---@param  callback?         uv.new_async.callback
+---@return uv.uv_async_t|nil async
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.new_async(callback) end
+
+
+--- Creates and initializes a new `uv_check_t`. Returns the Lua userdata wrapping
+--- it.
+---
+---@return uv.uv_check_t|nil check
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.new_check() end
+
+
+--- Creates and initializes a new `uv_fs_event_t`. Returns the Lua userdata wrapping
+--- it.
+---
+---@return uv.uv_fs_event_t|nil fs_event
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.new_fs_event() end
+
+
+--- Creates and initializes a new `uv_fs_poll_t`. Returns the Lua userdata wrapping
+--- it.
+---
+---@return uv.uv_fs_poll_t|nil fs_poll
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.new_fs_poll() end
+
+
+--- Creates and initializes a new `uv_idle_t`. Returns the Lua userdata wrapping
+--- it.
+---
+---@return uv.uv_idle_t|nil idle
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.new_idle() end
+
+
+--- Creates and initializes a new `uv_pipe_t`. Returns the Lua userdata wrapping
+--- it. The `ipc` argument is a boolean to indicate if this pipe will be used for
+--- handle passing between processes.
+---
+---@param  ipc?             boolean|false
+---@return uv.uv_pipe_t|nil pipe
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.new_pipe(ipc) end
+
+
+--- Initialize the handle using a file descriptor.
+---
+--- The file descriptor is set to non-blocking mode.
+---
+---@param  fd               integer
+---@return uv.uv_poll_t|nil poll
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.new_poll(fd) end
+
+
+--- Creates and initializes a new `uv_prepare_t`. Returns the Lua userdata wrapping
+--- it.
+---
+---@return uv.uv_prepare_t|nil prepare
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.new_prepare() end
+
+
+--- Creates and initializes a new `uv_signal_t`. Returns the Lua userdata wrapping
+--- it.
+---
+---@return uv.uv_signal_t|nil signal
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.new_signal() end
+
+
+--- Initialize the handle using a socket descriptor. On Unix this is identical to
+--- `uv.new_poll()`. On windows it takes a SOCKET handle.
+---
+--- The socket is set to non-blocking mode.
+---
+---@param  fd               integer
+---@return uv.uv_poll_t|nil poll
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.new_socket_poll(fd) end
+
+
+--- Creates and initializes a new `uv_tcp_t`. Returns the Lua userdata wrapping it.
+--- Flags may be a family string: `"unix"`, `"inet"`, `"inet6"`, `"ipx"`,
+--- `"netlink"`, `"x25"`, `"ax25"`, `"atmpvc"`, `"appletalk"`, or `"packet"`.
+---
+---@param  flags?          uv.socket.family
+---@return uv.uv_tcp_t|nil tcp
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.new_tcp(flags) end
+
+
+
+--- Creates and initializes a `luv_thread_t` (not `uv_thread_t`). Returns the Lua
+--- userdata wrapping it and asynchronously executes `entry`, which can be either
+--- a Lua function or a Lua function dumped to a string. Additional arguments `...`
+--- are passed to the `entry` function and an optional `options` table may be
+--- provided. Currently accepted `option` fields are `stack_size`.
+---
+---@param  options?            uv.new_thread.options
+---@param  entry               function
+---@param  ...                 uv.threadargs
+---@return uv.luv_thread_t|nil thread
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.new_thread(options, entry, ...) end
+
+
+
+--- Creates and initializes a new `uv_timer_t`. Returns the Lua userdata wrapping
+--- it.
+---
+--- ```lua
+--- -- Creating a simple setTimeout wrapper
+--- local function setTimeout(timeout, callback)
+---   local timer = uv.new_timer()
+---   timer:start(timeout, 0, function ()
+---     timer:stop()
+---     timer:close()
+---     callback()
+---   end)
+---   return timer
+--- end
+---
+--- -- Creating a simple setInterval wrapper
+--- local function setInterval(interval, callback)
+---   local timer = uv.new_timer()
+---   timer:start(interval, interval, function ()
+---     callback()
+---   end)
+---   return timer
+--- end
+---
+--- -- And clearInterval
+--- local function clearInterval(timer)
+---   timer:stop()
+---   timer:close()
+--- end
+--- ```
+---
+---@return uv.uv_timer_t|nil timer
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.new_timer() end
+
+
+
+--- Initialize a new TTY stream with the given file descriptor. Usually the file
+--- descriptor will be:
+---
+---  - 0 - stdin
+---  - 1 - stdout
+---  - 2 - stderr
+---
+--- On Unix this function will determine the path of the fd of the terminal using
+--- ttyname_r(3), open it, and use it if the passed file descriptor refers to a TTY.
+--- This lets libuv put the tty in non-blocking mode without affecting other
+--- processes that share the tty.
+---
+--- This function is not thread safe on systems that don’t support ioctl TIOCGPTN or TIOCPTYGNAME, for instance OpenBSD and Solaris.
+---
+--- **Note:** If reopening the TTY fails, libuv falls back to blocking writes.
+---
+---@param  fd              integer
+---@param  readable        boolean
+---@return uv.uv_tty_t|nil tty
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.new_tty(fd, readable) end
+
+
+
+--- Creates and initializes a new `uv_udp_t`. Returns the Lua userdata wrapping
+--- it. The actual socket is created lazily.
+---
+--- When specified, `family` must be one of `"unix"`, `"inet"`, `"inet6"`,
+--- `"ipx"`, `"netlink"`, `"x25"`, `"ax25"`, `"atmpvc"`, `"appletalk"`, or
+--- `"packet"`.
+---
+--- When specified, `mmsgs` determines the number of messages able to be received
+--- at one time via `recvmmsg(2)` (the allocated buffer will be sized to be able
+--- to fit the specified number of max size dgrams). Only has an effect on
+--- platforms that support `recvmmsg(2)`.
+---
+--- **Note:** For backwards compatibility reasons, `flags` can also be a string or
+--- integer. When it is a string, it will be treated like the `family` key above.
+--- When it is an integer, it will be used directly as the `flags` parameter when
+--- calling `uv_udp_init_ex`.
+---
+--- **Returns:** `uv_udp_t userdata` or `fail`
+---
+---@param  flags?          uv.new_udp.flags|uv.new_udp.flags.family|integer
+---@return uv.uv_udp_t|nil udp
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.new_udp(flags) end
+
+
+
+--- Creates and initializes a new `luv_work_ctx_t` (not `uv_work_t`). Returns the
+--- Lua userdata wrapping it.
+---
+--- **Parameters:**
+--- - `work_callback`: `function`
+---   - `...`: `threadargs` passed to/from `uv.queue_work(work_ctx, ...)`
+--- - `after_work_callback`: `function`
+---   - `...`: `threadargs` returned from `work_callback`
+---
+---@param work_callback uv.new_work.work_callback
+---@param after_work_callback uv.new_work.after_work_callback
+---@return uv.luv_work_ctx_t
+function uv.new_work(work_callback, after_work_callback) end
+
+
+
+--- Returns the current timestamp in milliseconds. The timestamp is cached at the
+--- start of the event loop tick, see `uv.update_time()` for details and rationale.
+---
+--- The timestamp increases monotonically from some arbitrary point in time. Don't
+--- make assumptions about the starting point, you will only get disappointed.
+---
+--- **Note**: Use `uv.hrtime()` if you need sub-millisecond granularity.
+---
+---@return integer
+function uv.now() end
+
+
+
+--- Returns all environmental variables as a dynamic table of names associated with
+--- their corresponding values.
+---
+--- **Warning:** This function is not thread safe.
+---
+---@return table<string, string>
+function uv.os_environ() end
+
+
+
+--- Returns password file information.
+---
+---@return uv.os_get_passwd.info
+function uv.os_get_passwd() end
+
+
+
+--- Returns the environment variable specified by `name` as string. The internal
+--- buffer size can be set by defining `size`. If omitted, `LUAL_BUFFERSIZE` is
+--- used. If the environment variable exceeds the storage available in the internal
+--- buffer, `ENOBUFS` is returned. If no matching environment variable exists,
+--- `ENOENT` is returned.
+---
+--- **Warning:** This function is not thread safe.
+---
+---@param name string
+---@param size? integer # (default = `LUAL_BUFFERSIZE`)
+---@return string|nil value
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.os_getenv(name, size) end
+
+
+
+--- Returns the hostname.
+---
+---@return string
+function uv.os_gethostname() end
+
+
+
+--- Returns the current process ID.
+---
+---@return number
+function uv.os_getpid() end
+
+
+
+--- Returns the parent process ID.
+---
+---@return number
+function uv.os_getppid() end
+
+
+
+--- Returns the scheduling priority of the process specified by `pid`.
+---
+---@param  pid        integer
+---@return number|nil priority
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.os_getpriority(pid) end
+
+
+
+--- **Warning:** This function is not thread safe.
+---
+---@return string|nil homedir
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.os_homedir() end
+
+
+--- Sets the environmental variable specified by `name` with the string `value`.
+---
+--- **Warning:** This function is not thread safe.
+---
+---@param  name        string
+---@param  value       string
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.os_setenv(name, value) end
+
+
+--- Sets the scheduling priority of the process specified by `pid`. The `priority`
+--- range is between -20 (high priority) and 19 (low priority).
+---
+---@param  pid         integer
+---@param  priority    integer
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.os_setpriority(pid, priority) end
+
+
+--- **Warning:** This function is not thread safe.
+---
+---@return string|nil tmpdir
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.os_tmpdir() end
+
+
+
+--- Returns system information.
+---
+---@return uv.os_uname.info
+function uv.os_uname() end
+
+
+
+--- **Warning:** This function is not thread safe.
+---
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.os_unsetenv() end
+
+
+
+--- Create a pair of connected pipe handles. Data may be written to the `write` fd and read from the `read` fd. The resulting handles can be passed to `pipe_open`, used with `spawn`, or for any other purpose.
+---
+--- Flags:
+---  - `nonblock`: Opens the specified socket handle for `OVERLAPPED` or `FIONBIO`/`O_NONBLOCK` I/O usage. This is recommended for handles that will be used by libuv, and not usually recommended otherwise.
+---
+--- Equivalent to `pipe(2)` with the `O_CLOEXEC` flag set.
+---
+--- **Returns:** `table` or `fail`
+--- - `read` : `integer` (file descriptor)
+--- - `write` : `integer` (file descriptor)
+---
+--- ```lua
+--- -- Simple read/write with pipe_open
+--- local fds = uv.pipe({nonblock=true}, {nonblock=true})
+---
+--- local read_pipe = uv.new_pipe()
+--- read_pipe:open(fds.read)
+---
+--- local write_pipe = uv.new_pipe()
+--- write_pipe:open(fds.write)
+---
+--- write_pipe:write("hello")
+--- read_pipe:read_start(function(err, chunk)
+---   assert(not err, err)
+---   print(chunk)
+--- end)
+--- ```
+---
+---@param  read_flags      uv.pipe.read_flags
+---@param  write_flags     uv.pipe.write_flags
+---@return uv.pipe.fds|nil fds
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.pipe(read_flags, write_flags) end
+
+
+--- Bind the pipe to a file path (Unix) or a name (Windows).
+---
+--- **Note**: Paths on Unix get truncated to sizeof(sockaddr_un.sun_path) bytes,
+--- typically between 92 and 108 bytes.
+---
+---@param  pipe       uv.uv_pipe_t
+---@param  name       string
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.pipe_bind(pipe, name) end
+
+
+--- Alters pipe permissions, allowing it to be accessed from processes run by different users.
+--- Makes the pipe writable or readable by all users. `flags` are: `"r"`, `"w"`, `"rw"`, or `"wr"`
+--- where `r` is `READABLE` and `w` is `WRITABLE`. This function is blocking.
+---
+---@param  pipe       uv.uv_pipe_t
+---@param  flags      uv.pipe_chmod.flags
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.pipe_chmod(pipe, flags) end
+
+
+--- Connect to the Unix domain socket or the named pipe.
+---
+--- **Note**: Paths on Unix get truncated to sizeof(sockaddr_un.sun_path) bytes,
+--- typically between 92 and 108 bytes.
+---
+---@param  pipe                uv.uv_pipe_t
+---@param  name                string
+---@param  callback?           uv.pipe_connect.callback
+---@return uv.uv_connect_t|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.pipe_connect(pipe, name, callback) end
+
+
+--- Get the name of the Unix domain socket or the named pipe to which the handle is
+--- connected.
+---
+---@param  pipe       uv.uv_pipe_t
+---@return string|nil peername
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.pipe_getpeername(pipe) end
+
+
+--- Get the name of the Unix domain socket or the named pipe.
+---
+---@param  pipe       uv.uv_pipe_t
+---@return string|nil sockname
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.pipe_getsockname(pipe) end
+
+
+--- Open an existing file descriptor or [`uv_handle_t`][] as a pipe.
+---
+--- **Note**: The file descriptor is set to non-blocking mode.
+---
+---@param  pipe       uv.uv_pipe_t
+---@param  fd         integer
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.pipe_open(pipe, fd) end
+
+
+--- Returns the pending pipe count for the named pipe.
+---
+---@param pipe uv.uv_pipe_t
+---@return integer
+function uv.pipe_pending_count(pipe) end
+
+
+--- Set the number of pending pipe instance handles when the pipe server is waiting
+--- for connections.
+---
+--- **Note**: This setting applies to Windows only.
+---
+---@param pipe uv.uv_pipe_t
+---@param count integer
+function uv.pipe_pending_instances(pipe, count) end
+
+
+--- Used to receive handles over IPC pipes.
+---
+--- First - call `uv.pipe_pending_count()`, if it's > 0 then initialize a handle of
+--- the given type, returned by `uv.pipe_pending_type()` and call
+--- `uv.accept(pipe, handle)`.
+---
+---@param pipe uv.uv_pipe_t
+---@return string
+function uv.pipe_pending_type(pipe) end
+
+
+--- Starts polling the file descriptor.
+---
+--- `events` are: `"r"`, `"w"`, `"rw"`, `"d"`,
+--- `"rd"`, `"wd"`, `"rwd"`, `"p"`, `"rp"`, `"wp"`, `"rwp"`, `"dp"`, `"rdp"`,
+--- `"wdp"`, or `"rwdp"` where `r` is `READABLE`, `w` is `WRITABLE`, `d` is
+--- `DISCONNECT`, and `p` is `PRIORITIZED`. As soon as an event is detected
+--- the callback will be called with status set to 0, and the detected events set on
+--- the events field.
+---
+--- The user should not close the socket while the handle is active. If the user
+--- does that anyway, the callback may be called reporting an error status, but this
+--- is not guaranteed.
+---
+--- **Note** Calling `uv.poll_start()` on a handle that is already active is fine.
+--- Doing so will update the events mask that is being watched for.
+---
+---@param  poll       uv.uv_poll_t
+---@param  events     uv.poll.eventspec
+---@param  callback   uv.poll_start.callback
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.poll_start(poll, events, callback) end
+
+
+--- Stop polling the file descriptor, the callback will no longer be called.
+---
+---@param  poll       uv.uv_poll_t
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.poll_stop(poll) end
+
+
+--- Start the handle with the given callback.
+---
+---@param  prepare    uv.uv_prepare_t
+---@param  callback   function
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.prepare_start(prepare, callback) end
+
+
+--- Stop the handle, the callback will no longer be called.
+---
+---@param  prepare    uv.uv_prepare_t
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.prepare_stop(prepare) end
+
+
+--- The same as `uv.print_all_handles()` except only active handles are printed.
+---
+--- **Note:** This is not available on Windows.
+---
+--- **Warning:** This function is meant for ad hoc debugging, there are no API/ABI
+--- stability guarantees.
+function uv.print_active_handles() end
+
+
+--- Prints all handles associated with the main loop to stderr. The format is
+--- `[flags] handle-type handle-address`. Flags are `R` for referenced, `A` for
+--- active and `I` for internal.
+---
+--- **Note:** This is not available on Windows.
+---
+--- **Warning:** This function is meant for ad hoc debugging, there are no API/ABI
+--- stability guarantees.
+function uv.print_all_handles() end
+
+
+--- Returns the handle's pid.
+---
+---@param process uv.uv_process_t
+---@return integer pid
+function uv.process_get_pid(process) end
+
+
+--- Sends the specified signal to the given process handle. Check the documentation
+--- on `uv_signal_t` for signal support, specially on Windows.
+---
+---@param  process    uv.uv_process_t
+---@param  signum     integer|string
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.process_kill(process, signum) end
+
+
+--- Queues a work request which will run `work_callback` in a new Lua state in a
+--- thread from the threadpool with any additional arguments from `...`. Values
+--- returned from `work_callback` are passed to `after_work_callback`, which is
+--- called in the main loop thread.
+---
+---@param  work_ctx    uv.luv_work_ctx_t
+---@param  ...         uv.threadargs
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.queue_work(work_ctx, ...) end
+
+
+--- Fills a string of length `len` with cryptographically strong random bytes
+--- acquired from the system CSPRNG. `flags` is reserved for future extension
+--- and must currently be `nil` or `0` or `{}`.
+---
+--- Short reads are not possible. When less than `len` random bytes are available,
+--- a non-zero error value is returned or passed to the callback. If the callback
+--- is omitted, this function is completed synchronously.
+---
+--- The synchronous version may block indefinitely when not enough entropy is
+--- available. The asynchronous version may not ever finish when the system is
+--- low on entropy.
+---
+--- **Returns (sync version):** `string` or `fail`
+---
+--- **Returns (async version):** `0` or `fail`
+---
+---@param  len        integer
+---@param  flags?     nil|0|{}
+---@return string|nil bytes
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(len:integer, flags?:nil, callback:uv.random.callback):0|nil, string?, string?
+function uv.random(len, flags) end
+
+
+--- Read data from an incoming stream. The callback will be made several times until
+--- there is no more data to read or `uv.read_stop()` is called. When we've reached
+--- EOF, `data` will be `nil`.
+---
+--- ```lua
+--- stream:read_start(function (err, chunk)
+---   if err then
+---     -- handle read error
+---   elseif chunk then
+---     -- handle data
+---   else
+---     -- handle disconnect
+---   end
+--- end)
+--- ```
+---
+---@param  stream     uv.uv_stream_t
+---@param  callback   uv.read_start.callback
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.read_start(stream, callback) end
+
+
+--- Stop reading data from the stream. The read callback will no longer be called.
+---
+--- This function is idempotent and may be safely called on a stopped stream.
+---
+---@param  stream     uv.uv_stream_t
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.read_stop(stream) end
+
+
+--- Gets or sets the size of the receive buffer that the operating system uses for
+--- the socket.
+---
+--- If `size` is omitted (or `0`), this will return the current send buffer size; otherwise, this will use `size` to set the new send buffer size.
+---
+--- This function works for TCP, pipe and UDP handles on Unix and for TCP and UDP
+--- handles on Windows.
+---
+--- **Note**: Linux will set double the size and return double the size of the
+--- original set value.
+---
+---@param  handle      uv.uv_handle_t
+---@param  size?       integer  # default is `0`
+---@return integer|nil size_or_ok
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.recv_buffer_size(handle, size) end
+
+
+--- Reference the given handle. References are idempotent, that is, if a handle is
+--- already referenced calling this function again will have no effect.
+---
+--- See [Reference counting][].
+---
+---@param handle uv.uv_handle_t
+function uv.ref(handle) end
+
+
+--- Returns the name of the struct for a given request (e.g. `"fs"` for `uv_fs_t`)
+--- and the libuv enum integer for the request's type (`uv_req_type`).
+---
+---@param  req              uv.uv_req_t
+---@return uv.req_type.name type
+---@return uv.req_type.enum enum
+function uv.req_get_type(req) end
+
+
+--- Returns the resident set size (RSS) for the current process.
+---
+---@return integer|nil rss
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.resident_set_memory() end
+
+
+--- This function runs the event loop. It will act differently depending on the
+--- specified mode:
+---
+---   - `"default"`: Runs the event loop until there are no more active and
+---   referenced handles or requests. Returns `true` if `uv.stop()` was called and
+---   there are still active handles or requests. Returns `false` in all other
+---   cases.
+---
+---   - `"once"`: Poll for I/O once. Note that this function blocks if there are no
+---   pending callbacks. Returns `false` when done (no active handles or requests
+---   left), or `true` if more callbacks are expected (meaning you should run the
+---   event loop again sometime in the future).
+---
+---   - `"nowait"`: Poll for I/O once but don't block if there are no pending
+---   callbacks. Returns `false` if done (no active handles or requests left),
+---   or `true` if more callbacks are expected (meaning you should run the event
+---   loop again sometime in the future).
+---
+--- **Note:** Luvit will implicitly call `uv.run()` after loading user code, but if
+--- you use the luv bindings directly, you need to call this after registering
+--- your initial set of event callbacks to start the event loop.
+---
+---@param mode? uv.run.mode
+---@return boolean
+function uv.run(mode) end
+
+
+--- Gets or sets the size of the send buffer that the operating system uses for the
+--- socket.
+---
+--- If `size` is omitted (or `0`), this will return the current send buffer size; otherwise, this will use `size` to set the new send buffer size.
+---
+--- This function works for TCP, pipe and UDP handles on Unix and for TCP and UDP
+--- handles on Windows.
+---
+--- **Returns:**
+--- - `integer` or `fail` (if `size` is `nil` or `0`)
+--- - `0` or `fail` (if `size` is not `nil` and not `0`)
+---
+--- **Note**: Linux will set double the size and return double the size of the
+--- original set value.
+---
+---@param  handle               uv.uv_handle_t
+---@param  size?                integer|0
+---@return integer|nil          success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil    err_name
+---
+---@overload fun(handle: uv.uv_handle_t):(size:integer|nil, err:uv.error.message|nil, err_name:uv.error.name|nil)
+---@overload fun(handle: uv.uv_handle_t, size:0):(size:integer|nil, err:uv.error.message|nil, err_name:uv.error.name|nil)
+function uv.send_buffer_size(handle, size) end
+
+
+--- Sets the title of the current process with the string `title`.
+---
+---@param  title      string
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.set_process_title(title) end
+
+
+--- Sets the group ID of the process with the integer `id`.
+---
+--- **Note:** This is not a libuv function and is not supported on Windows.
+---
+---@param id integer
+function uv.setgid(id) end
+
+
+--- Sets the user ID of the process with the integer `id`.
+---
+--- **Note:** This is not a libuv function and is not supported on Windows.
+---
+---@param id integer
+function uv.setuid(id) end
+
+
+--- Shutdown the outgoing (write) side of a duplex stream. It waits for pending
+--- write requests to complete. The callback is called after shutdown is complete.
+---
+---@param  stream               uv.uv_stream_t
+---@param  callback?            uv.shutdown.callback
+---@return uv.uv_shutdown_t|nil shutdown
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.shutdown(stream, callback) end
+
+
+--- Start the handle with the given callback, watching for the given signal.
+---
+---@param  signal     uv.uv_signal_t
+---@param  signum     integer|string
+---@param  callback   uv.signal_start.callback
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.signal_start(signal, signum, callback) end
+
+
+--- Same functionality as `uv.signal_start()` but the signal handler is reset the moment the signal is received.
+---
+---@param  signal     uv.uv_signal_t
+---@param  signum     integer|string
+---@param  callback   uv.signal_start_oneshot.callback
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.signal_start_oneshot(signal, signum, callback) end
+
+
+--- Stop the handle, the callback will no longer be called.
+---@param  signal     uv.uv_signal_t
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.signal_stop(signal) end
+
+
+--- Pauses the thread in which this is called for a number of milliseconds.
+---@param msec integer
+function uv.sleep(msec) end
+
+
+--- Create a pair of connected sockets with the specified properties. The resulting handles can be passed to `uv.tcp_open`, used with `uv.spawn`, or for any other purpose.
+---
+--- When specified as a string, `socktype` must be one of `"stream"`, `"dgram"`, `"raw"`,
+--- `"rdm"`, or `"seqpacket"`.
+---
+--- When `protocol` is set to 0 or nil, it will be automatically chosen based on the socket's domain and type. When `protocol` is specified as a string, it will be looked up using the `getprotobyname(3)` function (examples: `"ip"`, `"icmp"`, `"tcp"`, `"udp"`, etc).
+---
+--- Flags:
+---  - `nonblock`: Opens the specified socket handle for `OVERLAPPED` or `FIONBIO`/`O_NONBLOCK` I/O usage. This is recommended for handles that will be used by libuv, and not usually recommended otherwise.
+---
+--- Equivalent to `socketpair(2)` with a domain of `AF_UNIX`.
+---
+--- **Returns:** `table` or `fail`
+--- - `[1, 2]` : `integer` (file descriptor)
+---
+--- ```lua
+--- -- Simple read/write with tcp
+--- local fds = uv.socketpair(nil, nil, {nonblock=true}, {nonblock=true})
+---
+--- local sock1 = uv.new_tcp()
+--- sock1:open(fds[1])
+---
+--- local sock2 = uv.new_tcp()
+--- sock2:open(fds[2])
+---
+--- sock1:write("hello")
+--- sock2:read_start(function(err, chunk)
+---   assert(not err, err)
+---   print(chunk)
+--- end)
+--- ```
+---
+---@param  socktype?  uv.socketpair.socktype
+---@param  protocol?  uv.socketpair.protocol
+---@param  flags1?    uv.socketpair.flags
+---@param  flags2?    uv.socketpair.flags
+---@return uv.socketpair.fds|nil fds
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.socketpair(socktype, protocol, flags1, flags2) end
+
+
+--- Initializes the process handle and starts the process. If the process is
+--- successfully spawned, this function will return the handle and pid of the child
+--- process.
+---
+--- Possible reasons for failing to spawn would include (but not be limited to) the
+--- file to execute not existing, not having permissions to use the setuid or setgid
+--- specified, or not having enough memory to allocate for the new process.
+---
+--- ```lua
+--- local stdin = uv.new_pipe()
+--- local stdout = uv.new_pipe()
+--- local stderr = uv.new_pipe()
+---
+--- print("stdin", stdin)
+--- print("stdout", stdout)
+--- print("stderr", stderr)
+---
+--- local handle, pid = uv.spawn("cat", {
+---   stdio = {stdin, stdout, stderr}
+--- }, function(code, signal) -- on exit
+---   print("exit code", code)
+---   print("exit signal", signal)
+--- end)
+---
+--- print("process opened", handle, pid)
+---
+--- uv.read_start(stdout, function(err, data)
+---   assert(not err, err)
+---   if data then
+---     print("stdout chunk", stdout, data)
+---   else
+---     print("stdout end", stdout)
+---   end
+--- end)
+---
+--- uv.read_start(stderr, function(err, data)
+---   assert(not err, err)
+---   if data then
+---     print("stderr chunk", stderr, data)
+---   else
+---     print("stderr end", stderr)
+---   end
+--- end)
+---
+--- uv.write(stdin, "Hello World")
+---
+--- uv.shutdown(stdin, function()
+---   print("stdin shutdown", stdin)
+---   uv.close(handle, function()
+---     print("process closed", handle, pid)
+---   end)
+--- end)
+--- ```
+---
+--- The `options` table accepts the following fields:
+---
+---   - `options.args` - Command line arguments as a list of string. The first
+---   string should be the path to the program. On Windows, this uses CreateProcess
+---   which concatenates the arguments into a string. This can cause some strange
+---   errors. (See `options.verbatim` below for Windows.)
+---   - `options.stdio` - Set the file descriptors that will be made available to
+---   the child process. The convention is that the first entries are stdin, stdout,
+---   and stderr. (**Note**: On Windows, file descriptors after the third are
+---   available to the child process only if the child processes uses the MSVCRT
+---   runtime.)
+---   - `options.env` - Set environment variables for the new process.
+---   - `options.cwd` - Set the current working directory for the sub-process.
+---   - `options.uid` - Set the child process' user id.
+---   - `options.gid` - Set the child process' group id.
+---   - `options.verbatim` - If true, do not wrap any arguments in quotes, or
+---   perform any other escaping, when converting the argument list into a command
+---   line string. This option is only meaningful on Windows systems. On Unix it is
+---   silently ignored.
+---   - `options.detached` - If true, spawn the child process in a detached state -
+---   this will make it a process group leader, and will effectively enable the
+---   child to keep running after the parent exits. Note that the child process
+---   will still keep the parent's event loop alive unless the parent process calls
+---   `uv.unref()` on the child's process handle.
+---   - `options.hide` - If true, hide the subprocess console window that would
+---   normally be created. This option is only meaningful on Windows systems. On
+---   Unix it is silently ignored.
+---
+--- The `options.stdio` entries can take many shapes.
+---
+---   - If they are numbers, then the child process inherits that same zero-indexed
+---   fd from the parent process.
+---   - If `uv_stream_t` handles are passed in, those are used as a read-write pipe
+---   or inherited stream depending if the stream has a valid fd.
+---   - Including `nil` placeholders means to ignore that fd in the child process.
+---
+--- When the child process exits, `on_exit` is called with an exit code and signal.
+---
+---@param  path            string
+---@param  options         uv.spawn.options
+---@param  on_exit         uv.spawn.on_exit
+---@return uv.uv_process_t proc
+---@return integer         pid
+function uv.spawn(path, options, on_exit) end
+
+
+--- Stop the event loop, causing `uv.run()` to end as soon as possible. This
+--- will happen not sooner than the next loop iteration. If this function was called
+--- before blocking for I/O, the loop won't block for I/O on this iteration.
+function uv.stop() end
+
+
+--- Returns the stream's write queue size.
+---
+---@param stream uv.uv_stream_t
+---@return integer
+function uv.stream_get_write_queue_size(stream) end
+
+
+--- Enable or disable blocking mode for a stream.
+---
+--- When blocking mode is enabled all writes complete synchronously. The interface
+--- remains unchanged otherwise, e.g. completion or failure of the operation will
+--- still be reported through a callback which is made asynchronously.
+---
+--- **Warning**: Relying too much on this API is not recommended. It is likely to
+--- change significantly in the future. Currently this only works on Windows and
+--- only for `uv_pipe_t` handles. Also libuv currently makes no ordering guarantee
+--- when the blocking mode is changed after write requests have already been
+--- submitted. Therefore it is recommended to set the blocking mode immediately
+--- after opening or creating the stream.
+---
+---@param  stream     uv.uv_stream_t
+---@param  blocking   boolean
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.stream_set_blocking(stream, blocking) end
+
+
+--- Bind the handle to an host and port. `host` should be an IP address and
+--- not a domain name. Any `flags` are set with a table with field `ipv6only`
+--- equal to `true` or `false`.
+---
+--- When the port is already taken, you can expect to see an `EADDRINUSE` error
+--- from either `uv.tcp_bind()`, `uv.listen()` or `uv.tcp_connect()`. That is, a
+--- successful call to this function does not guarantee that the call to `uv.listen()`
+--- or `uv.tcp_connect()` will succeed as well.
+---
+--- Use a port of `0` to let the OS assign an ephemeral port.  You can look it up
+--- later using `uv.tcp_getsockname()`.
+---
+---@param  tcp        uv.uv_tcp_t
+---@param  host       string
+---@param  port       integer
+---@param  flags?     uv.tcp_bind.flags
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.tcp_bind(tcp, host, port, flags) end
+
+
+--- Resets a TCP connection by sending a RST packet. This is accomplished by setting
+--- the SO_LINGER socket option with a linger interval of zero and then calling
+--- `uv.close()`. Due to some platform inconsistencies, mixing of `uv.shutdown()`
+--- and `uv.tcp_close_reset()` calls is not allowed.
+---
+---@param  tcp        uv.uv_tcp_t
+---@param  callback?  function
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.tcp_close_reset(tcp, callback) end
+
+
+--- Establish an IPv4 or IPv6 TCP connection.
+---
+--- ```lua
+--- local client = uv.new_tcp()
+--- client:connect("127.0.0.1", 8080, function (err)
+---   -- check error and carry on.
+--- end)
+--- ```
+---
+---@param  tcp                 uv.uv_tcp_t
+---@param  host                string
+---@param  port                integer
+---@param  callback            uv.tcp_connect.callback
+---@return uv.uv_connect_t|nil conn
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.tcp_connect(tcp, host, port, callback) end
+
+
+--- Get the address of the peer connected to the handle.
+---
+---@param  tcp               uv.uv_tcp_t
+---@return uv.socketinfo|nil sockname
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.tcp_getpeername(tcp) end
+
+
+--- Get the current address to which the handle is bound.
+---
+---@param  tcp               uv.uv_tcp_t
+---@return uv.socketinfo|nil sockname
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.tcp_getsockname(tcp) end
+
+
+--- Enable / disable TCP keep-alive. `delay` is the initial delay in seconds,
+--- ignored when enable is `false`.
+---
+---@param  tcp        uv.uv_tcp_t
+---@param  enable     boolean
+---@param  delay?     integer
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.tcp_keepalive(tcp, enable, delay) end
+
+
+--- Enable / disable Nagle's algorithm.
+---
+---@param  tcp        uv.uv_tcp_t
+---@param  enable     boolean
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.tcp_nodelay(tcp, enable) end
+
+
+--- Open an existing file descriptor or SOCKET as a TCP handle.
+---
+--- **Note:** The passed file descriptor or SOCKET is not checked for its type, but it's required that it represents a valid stream socket.
+---
+---@param  tcp        uv.uv_tcp_t
+---@param  sock       integer
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.tcp_open(tcp, sock) end
+
+
+--- Enable / disable simultaneous asynchronous accept requests that are queued by
+--- the operating system when listening for new TCP connections.
+---
+--- This setting is used to tune a TCP server for the desired performance. Having
+--- simultaneous accepts can significantly improve the rate of accepting connections
+--- (which is why it is enabled by default) but may lead to uneven load distribution
+--- in multi-process setups.
+---
+---@param  tcp        uv.uv_tcp_t
+---@param  enable     boolean
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.tcp_simultaneous_accepts(tcp, enable) end
+
+
+--- **Deprecated:** Please use `uv.stream_get_write_queue_size()` instead.
+---
+---@param tcp uv.uv_tcp_t
+function uv.tcp_write_queue_size(tcp) end
+
+
+--- Returns a boolean indicating whether two threads are the same. This function is
+--- equivalent to the `__eq` metamethod.
+---
+---@param  thread       uv.luv_thread_t
+---@param  other_thread uv.luv_thread_t
+---@return boolean      equal
+function uv.thread_equal(thread, other_thread) end
+
+
+--- Waits for the `thread` to finish executing its entry function.
+---
+---@param  thread      uv.luv_thread_t
+---@return boolean|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.thread_join(thread) end
+
+
+--- Returns the handle for the thread in which this is called.
+---
+---@return uv.luv_thread_t
+function uv.thread_self() end
+
+
+--- Stop the timer, and if it is repeating restart it using the repeat value as the
+--- timeout. If the timer has never been started before it raises `EINVAL`.
+---
+---@param  timer      uv.uv_timer_t
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.timer_again(timer) end
+
+
+--- Get the timer due value or 0 if it has expired. The time is relative to `uv.now()`.
+---
+--- **Note**: New in libuv version 1.40.0.
+---
+---@param timer uv.uv_timer_t
+---@return integer
+function uv.timer_get_due_in(timer) end
+
+
+--- Get the timer repeat value.
+---
+---@param timer uv.uv_timer_t
+---@return integer
+function uv.timer_get_repeat(timer) end
+
+
+--- Set the repeat interval value in milliseconds. The timer will be scheduled to
+--- run on the given interval, regardless of the callback execution duration, and
+--- will follow normal timer semantics in the case of a time-slice overrun.
+---
+--- For example, if a 50 ms repeating timer first runs for 17 ms, it will be
+--- scheduled to run again 33 ms later. If other tasks consume more than the 33 ms
+--- following the first timer callback, then the callback will run as soon as
+--- possible.
+---
+---@param timer uv.uv_timer_t
+---@param repeat_ integer
+function uv.timer_set_repeat(timer, repeat_) end
+
+
+--- Start the timer. `timeout` and `repeat` are in milliseconds.
+---
+--- If `timeout` is zero, the callback fires on the next event loop iteration. If
+--- `repeat` is non-zero, the callback fires first after `timeout` milliseconds and
+--- then repeatedly after `repeat` milliseconds.
+---
+---@param  timer      uv.uv_timer_t
+---@param  timeout    integer
+---@param  repeat_    integer
+---@param  callback   function
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.timer_start(timer, timeout, repeat_, callback) end
+
+
+--- Stop the timer, the callback will not be called anymore.
+---
+---@param  timer      uv.uv_timer_t
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.timer_stop(timer) end
+
+
+--- Returns the libuv error message and error name (both in string form, see [`err` and `name` in Error Handling](#error-handling)) equivalent to the given platform dependent error code: POSIX error codes on Unix (the ones stored in errno), and Win32 error codes on Windows (those returned by GetLastError() or WSAGetLastError()).
+---
+---@param errcode integer
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.translate_sys_error(errcode) end
+
+
+--- Same as `uv.write()`, but won't queue a write request if it can't be completed
+--- immediately.
+---
+--- Will return number of bytes written (can be less than the supplied buffer size).
+---
+---@param  stream      uv.uv_stream_t
+---@param  data        uv.buffer
+---@return integer|nil bytes
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.try_write(stream, data) end
+
+
+--- Like `uv.write2()`, but with the properties of `uv.try_write()`. Not supported on Windows, where it returns `UV_EAGAIN`.
+---
+--- Will return number of bytes written (can be less than the supplied buffer size).
+---
+--- **Returns:** `integer` or `fail`
+---
+---@param  stream      uv.uv_stream_t
+---@param  data        uv.buffer
+---@param  send_handle uv.uv_stream_t
+---@return integer|nil bytes
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.try_write2(stream, data, send_handle) end
+
+
+--- Get the current state of whether console virtual terminal sequences are handled
+--- by libuv or the console. The return value is `"supported"` or `"unsupported"`.
+---
+--- This function is not implemented on Unix, where it returns `ENOTSUP`.
+---
+---@return "supported"|"unsupported"|nil state
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.tty_get_vterm_state() end
+
+
+--- Gets the current Window width and height.
+---
+--- **Returns:** `integer, integer` or `fail`
+---
+---@param  tty            uv.uv_tty_t
+---@return integer|nil    width
+---@return integer|string height_or_errmsg
+---@return uv.error.name|nil err_name
+function uv.tty_get_winsize(tty) end
+
+
+--- To be called when the program exits. Resets TTY settings to default values for
+--- the next process to take over.
+---
+--- This function is async signal-safe on Unix platforms but can fail with error
+--- code `EBUSY` if you call it when execution is inside `uv.tty_set_mode()`.
+---
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.tty_reset_mode() end
+
+
+--- Set the TTY using the specified terminal mode.
+---
+--- Parameter `mode` is a C enum with the following values:
+---
+---   - 0 - UV_TTY_MODE_NORMAL: Initial/normal terminal mode
+---   - 1 - UV_TTY_MODE_RAW: Raw input mode (On Windows, ENABLE_WINDOW_INPUT is
+---   also enabled)
+---   - 2 - UV_TTY_MODE_IO: Binary-safe I/O mode for IPC (Unix-only)
+---
+---@param  tty        uv.uv_tty_t
+---@param  mode       uv.tty.mode
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.tty_set_mode(tty, mode) end
+
+
+--- Controls whether console virtual terminal sequences are processed by libuv or
+--- console. Useful in particular for enabling ConEmu support of ANSI X3.64 and
+--- Xterm 256 colors. Otherwise Windows10 consoles are usually detected
+--- automatically. State should be one of: `"supported"` or `"unsupported"`.
+---
+--- This function is only meaningful on Windows systems. On Unix it is silently
+--- ignored.
+---
+---@param state "supported"|"unsupported"
+function uv.tty_set_vterm_state(state) end
+
+
+--- Bind the UDP handle to an IP address and port. Any `flags` are set with a table
+--- with fields `reuseaddr` or `ipv6only` equal to `true` or `false`.
+---
+---@param  udp        uv.uv_udp_t
+---@param  host       string
+---@param  port       integer
+---@param  flags?     uv.udp_bind.flags
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.udp_bind(udp, host, port, flags) end
+
+
+--- Associate the UDP handle to a remote address and port, so every message sent by
+--- this handle is automatically sent to that destination. Calling this function
+--- with a NULL addr disconnects the handle. Trying to call `uv.udp_connect()` on an
+--- already connected handle will result in an `EISCONN` error. Trying to disconnect
+--- a handle that is not connected will return an `ENOTCONN` error.
+---
+---@param udp uv.uv_udp_t
+---@param host string
+---@param port integer
+---@return 0|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.udp_connect(udp, host, port) end
+
+
+--- Returns the handle's send queue count.
+---
+---@param  udp     uv.uv_udp_t
+---@return integer count
+function uv.udp_get_send_queue_count(udp) end
+
+
+--- Returns the handle's send queue size.
+---
+---@param  udp     uv.uv_udp_t
+---@return integer size
+function uv.udp_get_send_queue_size(udp) end
+
+
+--- Get the remote IP and port of the UDP handle on connected UDP handles.
+---
+---@param  udp                 uv.uv_udp_t
+---@return uv.udp.sockname|nil peername
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.udp_getpeername(udp) end
+
+
+--- Get the local IP and port of the UDP handle.
+---
+---@param  udp                 uv.uv_udp_t
+---@return uv.udp.sockname|nil sockname
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.udp_getsockname(udp) end
+
+
+--- Opens an existing file descriptor or Windows SOCKET as a UDP handle.
+---
+--- Unix only: The only requirement of the sock argument is that it follows the
+--- datagram contract (works in unconnected mode, supports sendmsg()/recvmsg(),
+--- etc). In other words, other datagram-type sockets like raw sockets or netlink
+--- sockets can also be passed to this function.
+---
+--- The file descriptor is set to non-blocking mode.
+---
+--- Note: The passed file descriptor or SOCKET is not checked for its type, but
+--- it's required that it represents a valid datagram socket.
+---
+---@param  udp        uv.uv_udp_t
+---@param  fd         integer
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.udp_open(udp, fd) end
+
+
+--- Prepare for receiving data. If the socket has not previously been bound with
+--- `uv.udp_bind()` it is bound to `0.0.0.0` (the "all interfaces" IPv4 address)
+--- and a random port number.
+---
+---@param  udp        uv.uv_udp_t
+---@param  callback   uv.udp_recv_start.callback
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.udp_recv_start(udp, callback) end
+
+
+--- Stop listening for incoming datagrams.
+---
+---@param  udp        uv.uv_udp_t
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.udp_recv_stop(udp) end
+
+
+--- Send data over the UDP socket. If the socket has not previously been bound
+--- with `uv.udp_bind()` it will be bound to `0.0.0.0` (the "all interfaces" IPv4
+--- address) and a random port number.
+---
+---@param  udp                  uv.uv_udp_t
+---@param  data                 uv.buffer
+---@param  host                 string
+---@param  port                 integer
+---@param  callback             uv.udp_send.callback
+---@return uv.uv_udp_send_t|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.udp_send(udp, data, host, port, callback) end
+
+
+--- Set broadcast on or off.
+---
+---@param  udp        uv.uv_udp_t
+---@param  on         boolean
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.udp_set_broadcast(udp, on) end
+
+
+--- Set membership for a multicast address. `multicast_addr` is multicast address to
+--- set membership for. `interface_addr` is interface address. `membership` can be
+--- the string `"leave"` or `"join"`.
+---
+---@param  udp            uv.uv_udp_t
+---@param  multicast_addr string
+---@param  interface_addr string
+---@param  membership     "leave"|"join"
+---@return 0|nil          success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.udp_set_membership(udp, multicast_addr, interface_addr, membership) end
+
+
+--- Set the multicast interface to send or receive data on.
+---
+---@param  udp            uv.uv_udp_t
+---@param  interface_addr string
+---@return 0|nil          success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.udp_set_multicast_interface(udp, interface_addr) end
+
+
+--- Set IP multicast loop flag. Makes multicast packets loop back to local
+--- sockets.
+---
+---@param  udp        uv.uv_udp_t
+---@param  on         boolean
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.udp_set_multicast_loop(udp, on) end
+
+
+--- Set the multicast ttl.
+---
+--- `ttl` is an integer 1 through 255.
+---
+---@param  udp        uv.uv_udp_t
+---@param  ttl        integer
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.udp_set_multicast_ttl(udp, ttl) end
+
+
+--- Set membership for a source-specific multicast group. `multicast_addr` is multicast
+--- address to set membership for. `interface_addr` is interface address. `source_addr`
+--- is source address. `membership` can be the string `"leave"` or `"join"`.
+---
+---@param  udp            uv.uv_udp_t
+---@param  multicast_addr string
+---@param  interface_addr string|nil
+---@param  source_addr    string
+---@param  membership     "leave"|"join"
+---@return 0|nil          success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.udp_set_source_membership(udp, multicast_addr, interface_addr, source_addr, membership) end
+
+
+--- Set the time to live.
+---
+--- `ttl` is an integer 1 through 255.
+---
+---@param  udp        uv.uv_udp_t
+---@param  ttl        integer
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.udp_set_ttl(udp, ttl) end
+
+
+--- Same as `uv.udp_send()`, but won't queue a send request if it can't be
+--- completed immediately.
+---
+---@param  udp         uv.uv_udp_t
+---@param  data        uv.buffer
+---@param  host        string
+---@param  port        integer
+---@return integer|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.udp_try_send(udp, data, host, port) end
+
+
+--- Un-reference the given handle. References are idempotent, that is, if a handle
+--- is not referenced calling this function again will have no effect.
+---
+--- See [Reference counting][].
+---
+---@param handle uv.uv_handle_t
+function uv.unref(handle) end
+
+
+--- Update the event loop's concept of "now". Libuv caches the current time at the
+--- start of the event loop tick in order to reduce the number of time-related
+--- system calls.
+---
+--- You won't normally need to call this function unless you have callbacks that
+--- block the event loop for longer periods of time, where "longer" is somewhat
+--- subjective but probably on the order of a millisecond or more.
+function uv.update_time() end
+
+
+--- Returns the current system uptime in seconds.
+---
+---@return number|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.uptime() end
+
+
+--- Returns the libuv version packed into a single integer. 8 bits are used for each
+--- component, with the patch number stored in the 8 least significant bits. For
+--- example, this would be 0x010203 in libuv 1.2.3.
+---
+---@return integer
+function uv.version() end
+
+
+--- Returns the libuv version number as a string. For example, this would be "1.2.3"
+--- in libuv 1.2.3. For non-release versions, the version suffix is included.
+---
+---@return string
+function uv.version_string() end
+
+
+--- Walk the list of handles: `callback` will be executed with each handle.
+---
+--- ```lua
+--- -- Example usage of uv.walk to close all handles that aren't already closing.
+--- uv.walk(function (handle)
+---   if not handle:is_closing() then
+---     handle:close()
+---   end
+--- end)
+--- ```
+---
+---@param callback uv.walk.callback
+function uv.walk(callback) end
+
+
+--- Write data to stream.
+---
+--- `data` can either be a Lua string or a table of strings. If a table is passed
+--- in, the C backend will use writev to send all strings in a single system call.
+---
+--- The optional `callback` is for knowing when the write is complete.
+---
+---@param  stream            uv.uv_stream_t
+---@param  data              uv.buffer
+---@param  callback?         uv.write.callback
+---@return uv.uv_write_t|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.write(stream, data, callback) end
+
+--- Extended write function for sending handles over a pipe. The pipe must be
+--- initialized with `ipc` option `true`.
+---
+--- **Note:** `send_handle` must be a TCP socket or pipe, which is a server or a
+--- connection (listening or connected state). Bound sockets or pipes will be
+--- assumed to be servers.
+---
+---@param  stream            uv.uv_stream_t
+---@param  data              uv.buffer
+---@param  send_handle       uv.uv_stream_t
+---@param  callback?         uv.write2.callback
+---@return uv.uv_write_t|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function uv.write2(stream, data, send_handle, callback) end
\ No newline at end of file
diff --git a/meta/3rd/luv/library/uv_async_t.lua b/meta/3rd/luv/library/uv_async_t.lua
new file mode 100644
index 00000000..73f17e38
--- /dev/null
+++ b/meta/3rd/luv/library/uv_async_t.lua
@@ -0,0 +1,35 @@
+---@meta
+
+--- Async handles allow the user to "wakeup" the event loop and get a callback
+--- called from another thread.
+---
+--- ```lua
+--- local async
+--- async = uv.new_async(function()
+---   print("async operation ran")
+---   async:close()
+--- end)
+---
+--- async:send()
+--- ```
+---
+---@class uv.uv_async_t : uv.uv_handle_t
+---
+local async
+
+--- Wakeup the event loop and call the async handle's callback.
+---
+--- **Note**: It's safe to call this function from any thread. The callback will be
+--- called on the loop thread.
+---
+--- **Warning**: libuv will coalesce calls to `uv.async_send(async)`, that is, not
+--- every call to it will yield an execution of the callback. For example: if
+--- `uv.async_send()` is called 5 times in a row before the callback is called, the
+--- callback will only be called once. If `uv.async_send()` is called again after
+--- the callback was called, it will be called again.
+---
+---@param  ...        uv.threadargs
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function async:send(...) end
\ No newline at end of file
diff --git a/meta/3rd/luv/library/uv_check_t.lua b/meta/3rd/luv/library/uv_check_t.lua
new file mode 100644
index 00000000..3c131ba9
--- /dev/null
+++ b/meta/3rd/luv/library/uv_check_t.lua
@@ -0,0 +1,29 @@
+---@meta
+
+--- Check handles will run the given callback once per loop iteration, right after
+--- polling for I/O.
+---
+--- ```lua
+--- local check = uv.new_check()
+--- check:start(function()
+---   print("After I/O polling")
+--- end)
+--- ```
+---
+---@class uv.uv_check_t : uv.uv_handle_t
+local check
+
+--- Start the handle with the given callback.
+---
+---@param  callback   function
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function check:start(callback) end
+
+--- Stop the handle, the callback will no longer be called.
+---
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function check:stop() end
\ No newline at end of file
diff --git a/meta/3rd/luv/library/uv_fs_event_t.lua b/meta/3rd/luv/library/uv_fs_event_t.lua
new file mode 100644
index 00000000..87fab6b2
--- /dev/null
+++ b/meta/3rd/luv/library/uv_fs_event_t.lua
@@ -0,0 +1,33 @@
+---@meta
+
+--- FS Event handles allow the user to monitor a given path for changes, for
+--- example, if the file was renamed or there was a generic change in it. This
+--- handle uses the best backend for the job on each platform.
+---
+---@class uv.uv_fs_event_t : uv.uv_handle_t
+local fs_event
+
+--- Get the path being monitored by the handle.
+---
+---@return string|nil path
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function fs_event:getpath() end
+
+--- Start the handle with the given callback, which will watch the specified path
+--- for changes.
+---
+---@param  path       string
+---@param  flags      uv.fs_event_start.flags
+---@param  callback   uv.fs_event_start.callback
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function fs_event:start(path, flags, callback) end
+
+--- Stop the handle, the callback will no longer be called.
+---
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function fs_event:stop() end
\ No newline at end of file
diff --git a/meta/3rd/luv/library/uv_fs_poll_t.lua b/meta/3rd/luv/library/uv_fs_poll_t.lua
new file mode 100644
index 00000000..2e65cc42
--- /dev/null
+++ b/meta/3rd/luv/library/uv_fs_poll_t.lua
@@ -0,0 +1,35 @@
+---@meta
+
+--- FS Poll handles allow the user to monitor a given path for changes. Unlike
+--- `uv_fs_event_t`, fs poll handles use `stat` to detect when a file has changed so
+--- they can work on file systems where fs event handles can't.
+---
+---@class uv.uv_fs_poll_t : uv.uv_handle_t
+local fs_poll
+
+--- Get the path being monitored by the handle.
+---
+---@return string|nil path
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function fs_poll:getpath() end
+
+--- Check the file at `path` for changes every `interval` milliseconds.
+---
+--- **Note:** For maximum portability, use multi-second intervals. Sub-second
+--- intervals will not detect all changes on many file systems.
+---
+---@param  path       string
+---@param  interval   integer
+---@param  callback   uv.fs_poll_start.callback
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function fs_poll:start(path, interval, callback) end
+
+--- Stop the handle, the callback will no longer be called.
+---
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function fs_poll:stop() end
\ No newline at end of file
diff --git a/meta/3rd/luv/library/uv_handle_t.lua b/meta/3rd/luv/library/uv_handle_t.lua
new file mode 100644
index 00000000..b0d25bc1
--- /dev/null
+++ b/meta/3rd/luv/library/uv_handle_t.lua
@@ -0,0 +1,132 @@
+---@meta
+
+--- Base handle
+---
+--- `uv_handle_t` is the base type for all libuv handle types. All API functions
+--- defined here work with any handle type.
+---
+---@class uv.uv_handle_t : table
+---
+local handle
+
+--- Request handle to be closed.
+---
+--- The `callback` will be called asynchronously after this call.
+---
+--- This MUST be called on each handle before memory is released.
+---
+--- Handles that wrap file descriptors are closed immediately but `callback` will
+--- still be deferred to the next iteration of the event loop. It gives you a chance
+--- to free up any resources associated with the handle.
+---
+--- In-progress requests, like `uv_connect_t` or `uv_write_t`, are cancelled and
+--- have their callbacks called asynchronously with `ECANCELED`.
+---
+---@param callback? function
+function handle:close(callback) end
+
+--- Gets the platform dependent file descriptor equivalent.
+---
+--- The following handles are supported: TCP, pipes, TTY, UDP and poll. Calling
+--- this method on other handle type will fail with `EINVAL`.
+---
+--- If a handle doesn't have an attached file descriptor yet or the handle itself
+--- has been closed, this function will return `EBADF`.
+---
+--- **Warning**: Be very careful when using this function. libuv assumes it's in
+--- control of the file descriptor so any change to it may lead to malfunction.
+---
+---@return integer|nil fileno
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function handle:fileno() end
+
+--- Returns the name of the struct for a given handle (e.g. `"pipe"` for `uv_pipe_t`)
+--- and the libuv enum integer for the handle's type (`uv_handle_type`).
+---
+---@return string type
+---@return integer enum
+function handle:get_type() end
+
+--- Returns `true` if the handle referenced, `false` if not.
+---
+---@return boolean|nil has_ref
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function handle:has_ref() end
+
+--- Returns `true` if the handle is active, `false` if it's inactive.
+---
+--- What "active” means depends on the type of handle:
+---
+--- - A `uv_async_t` handle is always active and cannot be deactivated, except by closing it with `uv.close()`.
+---
+--- - A `uv_pipe_t`, `uv_tcp_t`, `uv_udp_t`, etc. handle - basically any handle that deals with I/O - is active when it is doing something that involves I/O, like reading, writing, connecting, accepting new connections, etc.
+---
+--- - A `uv_check_t`, `uv_idle_t`, `uv_timer_t`, etc. handle is active when it has been started with a call to `uv.check_start()`, `uv.idle_start()`, `uv.timer_start()` etc. until it has been stopped with a call to its respective stop function.
+---
+---@return boolean|nil active
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function handle:is_active() end
+
+--- Returns `true` if the handle is closing or closed, `false` otherwise.
+---
+--- **Note**: This function should only be used between the initialization of the
+--- handle and the arrival of the close callback.
+---
+---@return boolean|nil closing
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function handle:is_closing() end
+
+--- Gets or sets the size of the receive buffer that the operating system uses for
+--- the socket.
+---
+--- If `size` is omitted (or `0`), this will return the current send buffer size; otherwise, this will use `size` to set the new send buffer size.
+---
+--- This function works for TCP, pipe and UDP handles on Unix and for TCP and UDP
+--- handles on Windows.
+---
+--- **Note**: Linux will set double the size and return double the size of the
+--- original set value.
+---
+---@param  size       integer
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(self):(current_size:integer|nil, err:uv.error.message|nil, err_name:uv.error.name|nil)
+---@overload fun(self, size: 0):(current_size:integer|nil, err:uv.error.message|nil, err_name:uv.error.name|nil)
+function handle:recv_buffer_size(size) end
+
+--- Reference the given handle.
+---
+--- References are idempotent, that is, if a handle is already referenced calling this function again will have no effect.
+function handle:ref() end
+
+
+--- Gets or sets the size of the send buffer that the operating system uses for the
+--- socket.
+---
+--- If `size` is omitted (or `0`), this will return the current send buffer size; otherwise, this will use `size` to set the new send buffer size.
+---
+--- This function works for TCP, pipe and UDP handles on Unix and for TCP and UDP
+--- handles on Windows.
+---
+--- **Note**: Linux will set double the size and return double the size of the
+--- original set value.
+---
+---@param  size        integer
+---@return integer|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+---
+---@overload fun(self):(current_size:integer|nil, err:uv.error.message|nil, err_name:uv.error.name|nil)
+---@overload fun(self, size: 0):(current_size:integer|nil, err:uv.error.message|nil, err_name:uv.error.name|nil)
+function handle:send_buffer_size(size) end
+
+
+--- Un-reference the given handle. References are idempotent, that is, if a handle
+--- is not referenced calling this function again will have no effect.
+function handle:unref() end
\ No newline at end of file
diff --git a/meta/3rd/luv/library/uv_idle_t.lua b/meta/3rd/luv/library/uv_idle_t.lua
new file mode 100644
index 00000000..22368193
--- /dev/null
+++ b/meta/3rd/luv/library/uv_idle_t.lua
@@ -0,0 +1,38 @@
+---@meta
+
+--- Idle handles will run the given callback once per loop iteration, right before
+--- the `uv_prepare_t` handles.
+---
+--- **Note**: The notable difference with prepare handles is that when there are
+--- active idle handles, the loop will perform a zero timeout poll instead of
+--- blocking for I/O.
+---
+--- **Warning**: Despite the name, idle handles will get their callbacks called on
+--- every loop iteration, not when the loop is actually "idle".
+---
+--- ```lua
+--- local idle = uv.new_idle()
+--- idle:start(function()
+---   print("Before I/O polling, no blocking")
+--- end)
+--- ```
+---
+---@class uv.uv_idle_t : uv.uv_handle_t
+---
+local idle
+
+--- Start the handle with the given callback.
+---
+---@param  callback   function
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function idle:start(callback) end
+
+--- Stop the handle, the callback will no longer be called.
+---
+---@param  check      any
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function idle:stop(check) end
\ No newline at end of file
diff --git a/meta/3rd/luv/library/uv_pipe_t.lua b/meta/3rd/luv/library/uv_pipe_t.lua
new file mode 100644
index 00000000..0efbb04f
--- /dev/null
+++ b/meta/3rd/luv/library/uv_pipe_t.lua
@@ -0,0 +1,103 @@
+---@meta
+
+--- Pipe handles provide an abstraction over local domain sockets on Unix and named pipes on Windows.
+---
+--- ```lua
+--- local pipe = uv.new_pipe(false)
+---
+--- pipe:bind('/tmp/sock.test')
+---
+--- pipe:listen(128, function()
+---   local client = uv.new_pipe(false)
+---   pipe:accept(client)
+---   client:write("hello!\n")
+---   client:close()
+--- end)
+--- ```
+---
+---@class uv.uv_pipe_t : uv.uv_stream_t
+---
+local pipe
+
+--- Bind the pipe to a file path (Unix) or a name (Windows).
+---
+--- **Note**: Paths on Unix get truncated to sizeof(sockaddr_un.sun_path) bytes,
+--- typically between 92 and 108 bytes.
+---
+---@param  name       string
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function pipe:bind(name) end
+
+--- Alters pipe permissions, allowing it to be accessed from processes run by different users.
+---
+--- Makes the pipe writable or readable by all users. `flags` are: `"r"`, `"w"`, `"rw"`, or `"wr"`
+--- where `r` is `READABLE` and `w` is `WRITABLE`.
+---
+--- This function is blocking.
+---
+---@param  flags      uv.pipe_chmod.flags
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function pipe:chmod(flags) end
+
+--- Connect to the Unix domain socket or the named pipe.
+---
+--- **Note**: Paths on Unix get truncated to sizeof(sockaddr_un.sun_path) bytes,
+--- typically between 92 and 108 bytes.
+---
+---@param  name                string
+---@param  callback?           uv.pipe_connect.callback
+---@return uv.uv_connect_t|nil conn
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function pipe:connect(name, callback) end
+
+--- Get the name of the Unix domain socket or the named pipe to which the handle is
+--- connected.
+---
+---@return string|nil peername
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function pipe:getpeername() end
+
+--- Get the name of the Unix domain socket or the named pipe.
+---
+---@return string|nil sockname
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function pipe:getsockname() end
+
+--- Open an existing file descriptor or `uv_handle_t` as a pipe.
+---
+--- **Note**: The file descriptor is set to non-blocking mode.
+---
+---@param  fd         integer
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function pipe:open(fd) end
+
+--- Returns the pending pipe count for the named pipe.
+---
+---@return integer count
+function pipe:pending_count() end
+
+--- Set the number of pending pipe instance handles when the pipe server is waiting
+--- for connections.
+---
+--- **Note**: This setting applies to Windows only.
+---
+---@param count integer
+function pipe:pending_instances(count) end
+
+--- Used to receive handles over IPC pipes.
+---
+--- First - call `uv.pipe_pending_count()`, if it's > 0 then initialize a handle of
+--- the given type, returned by `uv.pipe_pending_type()` and call
+--- `uv.accept(pipe, handle)`.
+---
+---@return string
+function pipe:pending_type() end
\ No newline at end of file
diff --git a/meta/3rd/luv/library/uv_poll_t.lua b/meta/3rd/luv/library/uv_poll_t.lua
new file mode 100644
index 00000000..31336152
--- /dev/null
+++ b/meta/3rd/luv/library/uv_poll_t.lua
@@ -0,0 +1,57 @@
+---@meta
+
+--- Poll handles are used to watch file descriptors for readability and writability,
+--- similar to the purpose of [poll(2)](http://linux.die.net/man/2/poll).
+---
+--- The purpose of poll handles is to enable integrating external libraries that
+--- rely on the event loop to signal it about the socket status changes, like c-ares
+--- or libssh2. Using `uv_poll_t` for any other purpose is not recommended;
+--- `uv_tcp_t`, `uv_udp_t`, etc. provide an implementation that is faster and more
+--- scalable than what can be achieved with `uv_poll_t`, especially on Windows.
+---
+--- It is possible that poll handles occasionally signal that a file descriptor is
+--- readable or writable even when it isn't. The user should therefore always be
+--- prepared to handle EAGAIN or equivalent when it attempts to read from or write
+--- to the fd.
+---
+--- It is not okay to have multiple active poll handles for the same socket, this
+--- can cause libuv to busyloop or otherwise malfunction.
+---
+--- The user should not close a file descriptor while it is being polled by an
+--- active poll handle. This can cause the handle to report an error, but it might
+--- also start polling another socket. However the fd can be safely closed
+--- immediately after a call to `poll:stop()` or `uv.close()`.
+---
+--- **Note**: On windows only sockets can be polled with poll handles. On Unix any
+--- file descriptor that would be accepted by poll(2) can be used.
+---
+---@class uv.uv_poll_t : uv.uv_handle_t
+local poll
+
+--- Starts polling the file descriptor.
+---
+--- `events` are: `"r"`, `"w"`, `"rw"`, `"d"`, `"rd"`, `"wd"`, `"rwd"`, `"p"`, `"rp"`, `"wp"`, `"rwp"`, `"dp"`, `"rdp"`, `"wdp"`, or `"rwdp"` where `r` is `READABLE`, `w` is `WRITABLE`, `d` is `DISCONNECT`, and `p` is `PRIORITIZED`.
+---
+--- As soon as an event is detected the callback will be called with status set to 0, and the detected events set on the events field.
+---
+--- The user should not close the socket while the handle is active. If the user
+--- does that anyway, the callback may be called reporting an error status, but this
+--- is not guaranteed.
+---
+--- **Note** Calling `poll:start()` on a handle that is already active is fine.
+--- Doing so will update the events mask that is being watched for.
+---
+---@param  events     uv.poll.eventspec
+---@param  callback   uv.poll_start.callback
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function poll:start(events, callback) end
+
+
+--- Stop polling the file descriptor, the callback will no longer be called.
+---
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function poll:stop() end
\ No newline at end of file
diff --git a/meta/3rd/luv/library/uv_prepare_t.lua b/meta/3rd/luv/library/uv_prepare_t.lua
new file mode 100644
index 00000000..91e3231b
--- /dev/null
+++ b/meta/3rd/luv/library/uv_prepare_t.lua
@@ -0,0 +1,30 @@
+---@meta
+
+--- Prepare handles will run the given callback once per loop iteration, right
+--- before polling for I/O.
+---
+--- ```lua
+--- local prepare = uv.new_prepare()
+--- prepare:start(function()
+---   print("Before I/O polling")
+--- end)
+--- ```
+---
+---@class uv.uv_prepare_t : uv.uv_handle_t
+---
+local prepare
+
+--- Start the handle with the given callback.
+---
+---@param  callback   function
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function prepare:start(callback) end
+
+--- Stop the handle, the callback will no longer be called.
+---
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function prepare:stop() end
\ No newline at end of file
diff --git a/meta/3rd/luv/library/uv_process_t.lua b/meta/3rd/luv/library/uv_process_t.lua
new file mode 100644
index 00000000..7329df3c
--- /dev/null
+++ b/meta/3rd/luv/library/uv_process_t.lua
@@ -0,0 +1,22 @@
+---@meta
+
+--- Process handles will spawn a new process and allow the user to control it and
+--- establish communication channels with it using streams.
+---
+---@class uv.uv_process_t : uv.uv_handle_t
+local process
+
+--- Returns the handle's pid.
+---
+---@return integer pid
+function process:get_pid() end
+
+--- Sends the specified signal to the given process handle.
+---
+--- Check the documentation on `uv_signal_t` for signal support, specially on Windows.
+---
+---@param  signum     integer|string
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function process:kill(signum) end
\ No newline at end of file
diff --git a/meta/3rd/luv/library/uv_req_t.lua b/meta/3rd/luv/library/uv_req_t.lua
new file mode 100644
index 00000000..b39dc317
--- /dev/null
+++ b/meta/3rd/luv/library/uv_req_t.lua
@@ -0,0 +1,25 @@
+---@meta
+
+--- Base request
+---
+--- `uv_req_t` is the base type for all libuv request types.
+---
+---@class uv.uv_req_t : table
+---
+local req
+
+--- Cancel a pending request. Fails if the request is executing or has finished
+--- executing. Only cancellation of `uv_fs_t`, `uv_getaddrinfo_t`,
+--- `uv_getnameinfo_t` and `uv_work_t` requests is currently supported.
+---
+---@return 0|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function req:cancel() end
+
+--- Returns the name of the struct for a given request (e.g. `"fs"` for `uv_fs_t`)
+--- and the libuv enum integer for the request's type (`uv_req_type`).
+---
+---@return string type
+---@return integer enum
+function req:get_type() end
\ No newline at end of file
diff --git a/meta/3rd/luv/library/uv_signal_t.lua b/meta/3rd/luv/library/uv_signal_t.lua
new file mode 100644
index 00000000..69be819e
--- /dev/null
+++ b/meta/3rd/luv/library/uv_signal_t.lua
@@ -0,0 +1,69 @@
+---@meta
+
+--- Signal handles implement Unix style signal handling on a per-event loop bases.
+---
+--- **Unix Notes:**
+---
+--- - SIGKILL and SIGSTOP are impossible to catch.
+---
+--- - Handling SIGBUS, SIGFPE, SIGILL or SIGSEGV via libuv results into undefined behavior.
+---
+--- - SIGABRT will not be caught by libuv if generated by abort(), e.g. through assert().
+---
+--- - On Linux SIGRT0 and SIGRT1 (signals 32 and 33) are used by the NPTL pthreads library to manage threads. Installing watchers for those signals will lead to unpredictable behavior and is strongly discouraged. Future versions of libuv may simply reject them.
+---
+--- **Windows Notes:**
+---
+--- Reception of some signals is emulated on Windows:
+--- - SIGINT is normally delivered when the user presses CTRL+C. However, like on Unix, it is not generated when terminal raw mode is enabled.
+---
+--- - SIGBREAK is delivered when the user pressed CTRL + BREAK.
+---
+--- - SIGHUP is generated when the user closes the console window. On SIGHUP the program is given approximately 10 seconds to perform cleanup. After that Windows will unconditionally terminate it.
+---
+--- - SIGWINCH is raised whenever libuv detects that the console has been resized. SIGWINCH is emulated by libuv when the program uses a uv_tty_t handle to write to the console. SIGWINCH may not always be delivered in a timely manner; libuv will only detect size changes when the cursor is being moved. When a readable `uv_tty_t` handle is used in raw mode, resizing the console buffer will also trigger a SIGWINCH signal.
+---
+--- - Watchers for other signals can be successfully created, but these signals are never received. These signals are: SIGILL, SIGABRT, SIGFPE, SIGSEGV, SIGTERM and SIGKILL.
+---
+--- - Calls to raise() or abort() to programmatically raise a signal are not detected by libuv; these will not trigger a signal watcher.
+---
+---
+--- ```lua
+--- -- Create a new signal handler
+--- local signal = uv.new_signal()
+--- -- Define a handler function
+--- uv.signal_start(signal, "sigint", function(signal)
+---   print("got " .. signal .. ", shutting down")
+---   os.exit(1)
+--- end)
+--- ```
+---
+---@class uv.uv_signal_t : uv.uv_handle_t
+---
+local signal
+
+--- Start the handle with the given callback, watching for the given signal.
+---
+---@param  signum     integer|string
+---@param  callback   uv.signal_start.callback
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function signal:start(signum, callback) end
+
+--- Same functionality as `signal:start()` but the signal handler is reset the moment the signal is received.
+---
+---@param  signum     integer|string
+---@param  callback   uv.signal_start_oneshot.callback
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function signal:start_oneshot(signum, callback) end
+
+
+--- Stop the handle, the callback will no longer be called.
+---
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function signal:stop() end
\ No newline at end of file
diff --git a/meta/3rd/luv/library/uv_stream_t.lua b/meta/3rd/luv/library/uv_stream_t.lua
new file mode 100644
index 00000000..2de883b7
--- /dev/null
+++ b/meta/3rd/luv/library/uv_stream_t.lua
@@ -0,0 +1,173 @@
+---@meta
+
+--- Stream handles provide an abstraction of a duplex communication channel.
+--- `uv_stream_t` is an abstract type, libuv provides 3 stream implementations
+--- in the form of `uv_tcp_t`, `uv_pipe_t` and `uv_tty_t`.
+---
+---@class uv.uv_stream_t : uv.uv_handle_t
+---
+local stream
+
+--- This call is used in conjunction with `uv.listen()` to accept incoming
+--- connections. Call this function after receiving a callback to accept the
+--- connection.
+---
+--- When the connection callback is called it is guaranteed that this function
+--- will complete successfully the first time. If you attempt to use it more than
+--- once, it may fail. It is suggested to only call this function once per
+--- connection call.
+---
+--- ```lua
+--- server:listen(128, function (err)
+---   local client = uv.new_tcp()
+---   server:accept(client)
+--- end)
+--- ```
+---
+---@param  client_stream uv.uv_stream_t
+---@return 0|nil         success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function stream:accept(client_stream) end
+
+--- Returns the stream's write queue size.
+---
+---@return integer size
+function stream:get_write_queue_size() end
+
+--- Returns `true` if the stream is readable, `false` otherwise.
+---
+---@return boolean readable
+function stream:is_readable() end
+
+--- Returns `true` if the stream is writable, `false` otherwise.
+---
+---@return boolean writable
+function stream:is_writable() end
+
+--- Start listening for incoming connections.
+---
+--- `backlog` indicates the number of connections the kernel might queue, same as `listen(2)`.
+---
+--- When a new incoming connection is received the callback is called.
+---
+---@param  backlog    integer
+---@param  callback   uv.listen.callback
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function stream:listen(backlog, callback) end
+
+--- Read data from an incoming stream.
+---
+--- The callback will be made several times until there is no more data to read or `stream:read_stop()` is called.
+---
+--- When we've reached EOF, `data` will be `nil`.
+---
+--- ```lua
+--- stream:read_start(function (err, chunk)
+---   if err then
+---     -- handle read error
+---   elseif chunk then
+---     -- handle data
+---   else
+---     -- handle disconnect
+---   end
+--- end)
+--- ```
+---
+---@param  callback   uv.read_start.callback
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function stream:read_start(callback) end
+
+--- Stop reading data from the stream.
+---
+--- The read callback will no longer be called.
+---
+--- This function is idempotent and may be safely called on a stopped stream.
+---
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function stream:read_stop() end
+
+--- Enable or disable blocking mode for a stream.
+---
+--- When blocking mode is enabled all writes complete synchronously. The interface
+--- remains unchanged otherwise, e.g. completion or failure of the operation will
+--- still be reported through a callback which is made asynchronously.
+---
+--- **Warning**: Relying too much on this API is not recommended. It is likely to
+--- change significantly in the future. Currently this only works on Windows and
+--- only for `uv_pipe_t` handles. Also libuv currently makes no ordering guarantee
+--- when the blocking mode is changed after write requests have already been
+--- submitted. Therefore it is recommended to set the blocking mode immediately
+--- after opening or creating the stream.
+---
+---@param  blocking   boolean
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function stream:set_blocking(blocking) end
+
+--- Shutdown the outgoing (write) side of a duplex stream. It waits for pending
+--- write requests to complete. The callback is called after shutdown is complete.
+---
+---@param  callback?            uv.shutdown.callback
+---@return uv.uv_shutdown_t|nil shutdown
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function stream:shutdown(callback) end
+
+--- Same as `stream:write()`, but won't queue a write request if it can't be completed
+--- immediately.
+---
+--- Will return number of bytes written (can be less than the supplied buffer size).
+---
+---@param  data        uv.buffer
+---@return integer|nil bytes
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function stream:try_write(data) end
+
+--- Like `stream:write2()`, but with the properties of `stream:try_write()`. Not supported on Windows, where it returns `UV_EAGAIN`.
+---
+--- Will return number of bytes written (can be less than the supplied buffer size).
+---
+---@param  data        uv.buffer
+---@param  send_handle uv.uv_stream_t
+---@return integer|nil bytes
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function stream:try_write2(data, send_handle) end
+
+--- Write data to stream.
+---
+--- `data` can either be a Lua string or a table of strings. If a table is passed
+--- in, the C backend will use writev to send all strings in a single system call.
+---
+--- The optional `callback` is for knowing when the write is complete.
+---
+---@param  data              uv.buffer
+---@param  callback?         uv.write.callback
+---@return uv.uv_write_t|nil bytes
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function stream:write(data, callback) end
+
+--- Extended write function for sending handles over a pipe. The pipe must be
+--- initialized with `ipc` option `true`.
+---
+--- **Note:** `send_handle` must be a TCP socket or pipe, which is a server or a
+--- connection (listening or connected state). Bound sockets or pipes will be
+--- assumed to be servers.
+---
+---@param  data              uv.buffer
+---@param  send_handle       uv.uv_stream_t
+---@param  callback?         uv.write2.callback
+---@return uv.uv_write_t|nil write
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function stream:write2(data, send_handle, callback) end
\ No newline at end of file
diff --git a/meta/3rd/luv/library/uv_tcp_t.lua b/meta/3rd/luv/library/uv_tcp_t.lua
new file mode 100644
index 00000000..8dee919f
--- /dev/null
+++ b/meta/3rd/luv/library/uv_tcp_t.lua
@@ -0,0 +1,112 @@
+---@meta
+
+--- TCP handles are used to represent both TCP streams and servers.
+---
+---@class uv.uv_tcp_t : uv.uv_stream_t
+local tcp
+
+--- Bind the handle to an host and port.
+---
+--- Any `flags` are set with a table with field `ipv6only` equal to `true` or `false`.
+---
+--- When the port is already taken, you can expect to see an `EADDRINUSE` error
+--- from either `tcp:bind()`, `uv.listen()` or `tcp:connect()`. That is, a
+--- successful call to this function does not guarantee that the call to `uv.listen()`
+--- or `tcp:connect()` will succeed as well.
+---
+--- Use a port of `0` to let the OS assign an ephemeral port.  You can look it up
+--- later using `tcp:getsockname()`.
+---
+---@param  addr       string            # must be an IP address and not a hostname
+---@param  port       integer           # set to `0` to allow the OS to assign an ephemeral port
+---@param  flags?     uv.tcp_bind.flags
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function tcp:bind(addr, port, flags) end
+
+--- Resets a TCP connection by sending a RST packet. This is accomplished by setting
+--- the SO_LINGER socket option with a linger interval of zero and then calling
+--- `uv.close()`. Due to some platform inconsistencies, mixing of `uv.shutdown()`
+--- and `tcp:close_reset()` calls is not allowed.
+---
+---@param  callback?  function
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function tcp:close_reset(callback) end
+
+--- Establish an IPv4 or IPv6 TCP connection.
+---
+--- ```lua
+--- local client = uv.new_tcp()
+--- client:connect("127.0.0.1", 8080, function (err)
+---   -- check error and carry on.
+--- end)
+--- ```
+---
+---@param  host                string
+---@param  port                integer
+---@param  callback            uv.tcp_connect.callback
+---@return uv.uv_connect_t|nil conn
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function tcp:connect(host, port, callback) end
+
+--- Get the address of the peer connected to the handle.
+---
+---@return uv.socketinfo|nil peername
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function tcp:getpeername() end
+
+--- Get the current address to which the handle is bound.
+---
+---@return uv.socketinfo|nil sockname
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function tcp:getsockname() end
+
+--- Enable / disable TCP keep-alive.
+---
+---@param  enable     boolean
+---@param  delay?     integer # initial delay, in seconds
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function tcp:keepalive(enable, delay) end
+
+--- Enable / disable Nagle's algorithm.
+---
+---@param  enable     boolean
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function tcp:nodelay(enable) end
+
+--- Open an existing file descriptor or SOCKET as a TCP handle.
+---
+--- **Note:** The passed file descriptor or SOCKET is not checked for its type, but it's required that it represents a valid stream socket.
+---
+---@param  sock       integer
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function tcp:open(sock) end
+
+--- Enable / disable simultaneous asynchronous accept requests that are queued by
+--- the operating system when listening for new TCP connections.
+---
+--- This setting is used to tune a TCP server for the desired performance. Having
+--- simultaneous accepts can significantly improve the rate of accepting connections
+--- (which is why it is enabled by default) but may lead to uneven load distribution
+--- in multi-process setups.
+---
+---@param  enable     boolean
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function tcp:simultaneous_accepts(enable) end
+
+--- **Deprecated:** Please use `uv.stream_get_write_queue_size()` instead.
+function tcp:write_queue_size() end
\ No newline at end of file
diff --git a/meta/3rd/luv/library/uv_timer_t.lua b/meta/3rd/luv/library/uv_timer_t.lua
new file mode 100644
index 00000000..64a70418
--- /dev/null
+++ b/meta/3rd/luv/library/uv_timer_t.lua
@@ -0,0 +1,55 @@
+---@meta
+
+--- Timer handles are used to schedule callbacks to be called in the future.
+---
+---@class uv.uv_timer_t : uv.uv_handle_t
+local timer
+
+--- Stop the timer, and if it is repeating restart it using the repeat value as the
+--- timeout. If the timer has never been started before it raises `EINVAL`.
+---
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function timer:again() end
+
+--- Get the timer due value or 0 if it has expired. The time is relative to `uv.now()`.
+---
+--- **Note**: New in libuv version 1.40.0.
+---
+---@return integer
+function timer:get_due_in() end
+
+--- Get the timer repeat value.
+---
+---@return integer
+function timer:get_repeat() end
+
+--- Set the repeat interval value in milliseconds. The timer will be scheduled to
+--- run on the given interval, regardless of the callback execution duration, and
+--- will follow normal timer semantics in the case of a time-slice overrun.
+---
+--- For example, if a 50 ms repeating timer first runs for 17 ms, it will be
+--- scheduled to run again 33 ms later. If other tasks consume more than the 33 ms
+--- following the first timer callback, then the callback will run as soon as
+--- possible.
+---
+---@param repeat_ integer
+function timer:set_repeat(repeat_) end
+
+--- Start the timer. `timeout` and `repeat_` are in milliseconds.
+---
+---@param  timeout    integer # Timeout, in milliseconds. If timeout is zero, the callback fires on the next event loop iteration.
+---@param  repeat_    integer # Repeat interval, in milliseconds. If non-zero, the callback fires after `timeout` milliseconds and then repeatedly after `repeat_` milliseconds.
+---@param  callback   function
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function timer:start(timeout, repeat_, callback) end
+
+--- Stop the timer, the callback will not be called anymore.
+---
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function timer:stop() end
\ No newline at end of file
diff --git a/meta/3rd/luv/library/uv_tty_t.lua b/meta/3rd/luv/library/uv_tty_t.lua
new file mode 100644
index 00000000..15e6fe46
--- /dev/null
+++ b/meta/3rd/luv/library/uv_tty_t.lua
@@ -0,0 +1,44 @@
+---@meta
+
+--- TTY handles represent a stream for the console.
+---
+--- ```lua
+--- -- Simple echo program
+--- local stdin = uv.new_tty(0, true)
+--- local stdout = uv.new_tty(1, false)
+---
+--- stdin:read_start(function (err, data)
+---   assert(not err, err)
+---   if data then
+---     stdout:write(data)
+---   else
+---     stdin:close()
+---     stdout:close()
+---   end
+--- end)
+--- ```
+---
+---@class uv.uv_tty_t : uv.uv_stream_t
+local tty
+
+--- Gets the current Window width and height.
+---
+---@return integer|nil    width
+---@return integer|uv.error.message height_or_err
+---@return uv.error.name|nil err_name
+function tty:get_winsize() end
+
+--- Set the TTY using the specified terminal mode.
+---
+--- Parameter `mode` is a C enum with the following values:
+---
+---   - 0 - UV_TTY_MODE_NORMAL: Initial/normal terminal mode
+---   - 1 - UV_TTY_MODE_RAW: Raw input mode (On Windows, ENABLE_WINDOW_INPUT is
+---   also enabled)
+---   - 2 - UV_TTY_MODE_IO: Binary-safe I/O mode for IPC (Unix-only)
+---
+---@param  mode       uv.tty.mode
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function tty:set_mode(mode) end
\ No newline at end of file
diff --git a/meta/3rd/luv/library/uv_udp_t.lua b/meta/3rd/luv/library/uv_udp_t.lua
new file mode 100644
index 00000000..a2dfd676
--- /dev/null
+++ b/meta/3rd/luv/library/uv_udp_t.lua
@@ -0,0 +1,175 @@
+---@meta
+
+--- UDP handles encapsulate UDP communication for both clients and servers.
+---
+---@class uv.uv_udp_t : uv.uv_handle_t
+local udp
+
+--- Bind the UDP handle to an IP address and port. Any `flags` are set with a table
+--- with fields `reuseaddr` or `ipv6only` equal to `true` or `false`.
+---
+---@param  host       string
+---@param  port       integer
+---@param  flags?     uv.udp_bind.flags
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function udp:bind(host, port, flags) end
+
+
+--- Associate the UDP handle to a remote address and port, so every message sent by
+--- this handle is automatically sent to that destination.
+--
+--- Calling this function with a NULL addr disconnects the handle. Trying to call `udp:connect()` on an already connected handle will result in an `EISCONN` error. Trying to disconnect a handle that is not connected will return an `ENOTCONN` error.
+---
+---@param  host       string
+---@param  port       integer
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function udp:connect(host, port) end
+
+--- Returns the handle's send queue count.
+---
+---@return integer count
+function udp:get_send_queue_count() end
+
+--- Returns the handle's send queue size.
+---
+---@return integer size
+function udp:get_send_queue_size() end
+
+--- Get the remote IP and port of the UDP handle on connected UDP handles.
+---
+---@return uv.udp.sockname|nil peername
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function udp:getpeername() end
+
+--- Get the local IP and port of the UDP handle.
+---
+---@return uv.udp.sockname|nil sockname
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function udp:getsockname() end
+
+--- Opens an existing file descriptor or Windows SOCKET as a UDP handle.
+---
+--- Unix only: The only requirement of the sock argument is that it follows the
+--- datagram contract (works in unconnected mode, supports sendmsg()/recvmsg(),
+--- etc). In other words, other datagram-type sockets like raw sockets or netlink
+--- sockets can also be passed to this function.
+---
+--- The file descriptor is set to non-blocking mode.
+---
+--- Note: The passed file descriptor or SOCKET is not checked for its type, but
+--- it's required that it represents a valid datagram socket.
+---
+---@param  fd         integer
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function udp:open(fd) end
+
+--- Prepare for receiving data.
+---
+--- If the socket has not previously been bound with `udp:bind()` it is bound to `0.0.0.0` (the "all interfaces" IPv4 address) and a random port number.
+---
+---@param  callback   uv.udp_recv_start.callback
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function udp:recv_start(callback) end
+
+--- Stop listening for incoming datagrams.
+---
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function udp:recv_stop() end
+
+--- Send data over the UDP socket.
+---
+--- If the socket has not previously been bound with `udp:bind()` it will be bound to `0.0.0.0` (the "all interfaces" IPv4 address) and a random port number.
+---
+---@param  data                 uv.buffer
+---@param  host                 string
+---@param  port                 integer
+---@param  callback             uv.udp_send.callback
+---@return uv.uv_udp_send_t|nil bytes
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function udp:send(data, host, port, callback) end
+
+--- Set broadcast on or off.
+---
+---@param  on         boolean
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function udp:set_broadcast(on) end
+
+--- Set membership for a multicast address.
+---
+---@param  multicast_addr string          # multicast address to set membership for
+---@param  interface_addr string          # interface address
+---@param  membership     "leave"|"join"  # membership intent
+---@return 0|nil          success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function udp:set_membership(multicast_addr, interface_addr, membership) end
+
+--- Set the multicast interface to send or receive data on.
+---
+---@param interface_addr string
+---@return 0|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function udp:set_multicast_interface(interface_addr) end
+
+--- Set IP multicast loop flag. Makes multicast packets loop back to local
+--- sockets.
+---
+---@param on boolean
+---@return 0|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function udp:set_multicast_loop(on) end
+
+--- Set the multicast ttl.
+---
+---@param  ttl        integer # an integer 1 through 255
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function udp:set_multicast_ttl(ttl) end
+
+--- Set membership for a source-specific multicast group.
+---
+---@param  multicast_addr  string         # multicast address to set membership for
+---@param  interface_addr? string         # interface address
+---@param  source_addr     string         # source address
+---@param  membership      "leave"|"join" # membership intent
+---@return 0|nil           success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function udp:set_source_membership(multicast_addr, interface_addr, source_addr, membership) end
+
+--- Set the time to live.
+---
+---@param  ttl        integer # integer 1 through 255
+---@return 0|nil      success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function udp:set_ttl(ttl) end
+
+--- Same as `udp:send()`, but won't queue a send request if it can't be
+--- completed immediately.
+---
+---@param  data        uv.buffer
+---@param  host        string
+---@param  port        integer
+---@return integer|nil success
+---@return uv.error.message|nil err
+---@return uv.error.name|nil err_name
+function udp:try_send(data, host, port) end
\ No newline at end of file