path: root/modules/lua/lua.luadoc

---
-- Dummy table.
-- @class table
-- @name _G
-- @field _G (table)
--   A global variable (not a function) that holds the global environment (see §2.2). Lua
--   itself does not use this variable; changing its value does not affect any environment,
--   nor vice versa.
-- @field _VERSION (string)
--   A global variable (not a function) that holds a string containing the running Lua version. The
--   current value of this variable is "`Lua 5.4`".
local _G

---
-- Raises an error if the value of its argument `v` is false (i.e., nil or false); otherwise,
-- returns all its arguments. In case of error, `message` is the error object; when absent,
-- it defaults to "assertion failed!".
function assert(v [, message]) end

---
-- This function is a generic interface to the garbage collector. It performs different functions
-- according to its first argument, `opt`:
--   "collect": performs a full garbage-collection cycle. This is the default option.
--   "stop": stops automatic execution of the garbage collector.
--   "restart": restarts automatic execution of the garbage collector.
--   "count": returns the total memory in use by Lua in Kbytes. The value has a fractional part,
--     so that it multiplied by 1024 gives the exact number of bytes in use by Lua.
--   "step": performs a garbage-collection step. The step "size" is controlled by `arg`. With a
--     zero value, the collector will perform one basic (indivisible) step. For non-zero values,
--     the collector will perform as if that amount of memory (in Kbytes) had been allocated
--     by Lua. Returns true if the step finished a collection cycle.
--   "isrunning": returns a boolean that tells whether the collector is running (i.e., not
--     stopped).
--   "incremental": change the collector mode to incremental. This option can be followed
--     by three numbers: the garbage-collector pause, the step multiplier, and the step size
--     (see §2.5.1). A zero means to not change that value.
--   "generational": change the collector mode to generational. This option can be followed
--     by two numbers: the garbage-collector minor multiplier and the major multiplier (see
--     §2.5.2). A zero means to not change that value.
--
-- See §2.5 for more details about garbage collection and some of these options.
function collectgarbage([opt [, arg]]) end

---
-- Opens the named file and executes its content as a Lua chunk. When called without arguments,
-- `dofile` executes the content of the standard input (`stdin`). Returns all values returned
-- by the chunk. In case of errors, `dofile` propagates the error to its caller. (That is,
-- `dofile` does not run in protected mode.)
function dofile([filename]) end

---
-- Raises an error (see §2.3) with `message` as the error object. This function never returns.
--
-- Usually, `error` adds some information about the error position at the beginning of the
-- message, if the message is a string. The `level` argument specifies how to get the error
-- position. With level 1 (the default), the error position is where the `error` function
-- was called. Level 2 points the error to where the function that called `error` was called;
-- and so on. Passing a level 0 avoids the addition of error position information to the message.
function error(message [, level]) end

---
-- Returns the current environment in use by the function. `f` can be a Lua function or a
-- number that specifies the function at that stack level: Level 1 is the function calling
-- `getfenv`. If the given function is not a Lua function, or if `f` is 0, `getfenv` returns
-- the global environment. The default for `f` is 1.
--
-- Deprecated in Lua 5.2.
function getfenv([f]) end

---
-- If `object` does not have a metatable, returns nil. Otherwise, if the object's metatable
-- has a `__metatable` field, returns the associated value. Otherwise, returns the metatable
-- of the given object.
function getmetatable(object) end

---
-- Returns three values (an iterator function, the table `t`, and 0) so that the construction
--
--   for i,v in ipairs(t) do *body* end
--
-- will iterate over the key-value pairs (`1,t[1]`), (`2,t[2]`), ···, up to the first
-- absent index.
function ipairs(t) end

---
-- Loads a chunk.
--
-- If `chunk` is a string, the chunk is this string. If `chunk` is a function, `load` calls
-- it repeatedly to get the chunk pieces. Each call to `chunk` must return a string that
-- concatenates with previous results. A return of an empty string, nil, or no value signals
-- the end of the chunk.
--
-- If there are no syntactic errors, `load` returns the compiled chunk as a function; otherwise,
-- it returns nil plus the error message.
--
-- When you load a main chunk, the resulting function will always have exactly one upvalue, the
-- `_ENV` variable (see §2.2). However, when you load a binary chunk created from a function
-- (see `string.dump`), the resulting function can have an arbitrary number of upvalues,
-- and there is no guarantee that its first upvalue will be the `_ENV` variable. (A non-main
-- function may not even have an `_ENV` upvalue.)
--
-- Regardless, if the resulting function has any upvalues, its first upvalue is set to the
-- value of `env`, if that parameter is given, or to the value of the global environment. Other
-- upvalues are initialized with nil. All upvalues are fresh, that is, they are not shared with
-- any other function.
--
-- `chunkname` is used as the name of the chunk for error messages and debug information (see
-- §4.7). When absent, it defaults to `chunk`, if `chunk` is a string, or to "`=(load)`"
-- otherwise.
--
-- The string `mode` controls whether the chunk can be text or binary (that is, a precompiled
-- chunk). It may be the string "`b`" (only binary chunks), "`t`" (only text chunks), or "`bt`"
-- (both binary and text). The default is "`bt`".
--
-- It is safe to load malformed binary chunks; `load` signals an appropriate error. However,
-- Lua does not check the consistency of the code inside binary chunks; running maliciously
-- crafted bytecode can crash the interpreter.
function load(chunk [, chunkname [, mode [, env]]]) end

---
-- Similar to `load`, but gets the chunk from file `filename` or from the standard input,
-- if no file name is given.
function loadfile([filename [, mode [, env]]]) end

---
-- Similar to `load`, but gets the chunk from the given string. To load and run a given string,
-- use the idiom assert(loadstring(s))() When absent, `chunkname` defaults to the given string.
--
-- Deprecated in Lua 5.2.
function loadstring(string [, chunkname])

---
-- Creates a module. If there is a table in `package.loaded[name]`, this table is the
-- module. Otherwise, if there is a global table `t` with the given name, this table is the
-- module. Otherwise creates a new table `t` and sets it as the value of the global `name`
-- and the value of `package.loaded[name]`. This function also initializes `t._NAME` with the
-- given name, `t._M` with the module (`t` itself), and `t._PACKAGE` with the package name
-- (the full module name minus last component; see below). Finally, `module` sets `t` as the
-- new environment of the current function and the new value of `package.loaded[name]`, so that
-- `require` returns `t`. If `name` is a compound name (that is, one with components separated
-- by dots), `module` creates (or reuses, if they already exist) tables for each component. For
-- instance, if `name` is `a.b.c`, then `module` stores the module table in field `c` of field
-- `b` of global `a`. This function can receive optional *options* after the module name,
-- where each option is a function to be applied over the module.
--
-- Deprecated in Lua 5.2.
function module(name [, ···]) end

---
-- Allows a program to traverse all fields of a table. Its first argument is a table and its
-- second argument is an index in this table. A call to `next` returns the next index of the
-- table and its associated value. When called with nil as its second argument, `next` returns
-- an initial index and its associated value. When called with the last index, or with nil in
-- an empty table, `next` returns nil. If the second argument is absent, then it is interpreted
-- as nil. In particular, you can use `next(t)` to check whether a table is empty.
--
-- The order in which the indices are enumerated is not specified, *even for numeric indices*. (To
-- traverse a table in numeric order, use a numerical `for`.)
--
-- The behavior of `next` is undefined if, during the traversal, you assign any value to a
-- non-existent field in the table. You may however modify existing fields. In particular,
-- you may set existing fields to nil.
function next(table [, index]) end

---
-- If `t` has a metamethod `__pairs`, calls it with `t` as argument and returns the first three
-- results from the call.
--
-- Otherwise, returns three values: the `next` function, the table `t`, and nil, so that the
-- construction
--
--   for k,v in pairs(t) do *body* end
--
-- will iterate over all key–value pairs of table `t`.
--
-- See function `next` for the caveats of modifying the table during its traversal.
function pairs(t) end

---
-- Calls the function `f` with the given arguments in *protected mode*. This means that any
-- error inside `f` is not propagated; instead, `pcall` catches the error and returns a status
-- code. Its first result is the status code (a boolean), which is true if the call succeeds
-- without errors. In such case, `pcall` also returns all results from the call, after this
-- first result. In case of any error, `pcall` returns false plus the error object. Note that
-- errors caught by `pcall` do not call a message handler.
function pcall(f [, arg1, ···]) end

---
-- Receives any number of arguments and prints their values to `stdout`, converting each argument
-- to a string following the same rules of `tostring`.
--
-- The function `print` is not intended for formatted output, but only as a quick way to show a
-- value, for instance for debugging. For complete control over the output, use `string.format`
-- and `io.write`.
function print(···) end

---
-- Checks whether `v1` is equal to `v2`, without invoking the `__eq` metamethod. Returns a boolean.
function rawequal(v1, v2) end

---
-- Gets the real value of `table[index]`, without using the `__index` metavalue. `table` must
-- be a table; `index` may be any value.
function rawget(table, index) end

---
-- Returns the length of the object `v`, which must be a table or a string, without invoking the
-- `__len` metamethod. Returns an integer.
--
-- New in Lua 5.2.
function rawlen(v) end

---
-- Sets the real value of `table[index]` to `value`, without using the `__newindex`
-- metavalue. `table` must be a table, `index` any value different from nil and NaN, and `value`
-- any Lua value.
--
-- This function returns `table`.
function rawset(table, index, value) end

---
-- Sets the environment to be used by the given function. `f` can be a Lua function or a
-- number that specifies the function at that stack level: Level 1 is the function calling
-- `setfenv`. `setfenv` returns the given function. As a special case, when `f` is 0 `setfenv`
-- changes the environment of the running thread. In this case, `setfenv` returns no values.
--
-- Deprecated in Lua 5.2.
function setfenv(f, table) end

---
-- If `index` is a number, returns all arguments after argument number `index`; a negative number
-- indexes from the end (-1 is the last argument). Otherwise, `index` must be the string `"#"`,
-- and `select` returns the total number of extra arguments it received.
function select(index, ···) end

---
-- Sets the metatable for the given table. If `metatable` is nil, removes the metatable of the
-- given table. If the original metatable has a `__metatable` field, raises an error.
--
-- This function returns `table`.
--
-- To change the metatable of other types from Lua code, you must use the debug library
-- (see §6.10).
function setmetatable(table, metatable) end

---
-- When called with no `base`, `tonumber` tries to convert its argument to a number. If the
-- argument is already a number or a string convertible to a number, then `tonumber` returns
-- this number; otherwise, it returns nil.
--
-- The conversion of strings can result in integers or floats, according to the lexical
-- conventions of Lua (see §3.1). The string may have leading and trailing spaces and a sign.
--
-- When called with `base`, then `e` must be a string to be interpreted as an integer numeral
-- in that base. The base may be any integer between 2 and 36, inclusive. In bases above 10,
-- the letter '`A`' (in either upper or lower case) represents 10, '`B`' represents 11, and so
-- forth, with '`Z`' representing 35. If the string `e` is not a valid numeral in the given base,
-- the function returns nil
function tonumber(e [, base]) end

---
-- Receives a value of any type and converts it to a string in a human-readable format. Floats
-- always produce strings with some floating-point indication (either a decimal dot or an
-- exponent).
--
-- If the metatable of `v` has a `__tostring` field, then `tostring` calls the corresponding
-- value with `v` as argument, and uses the result of the call as its result. Otherwise, if the
-- metatable of `v` has a `__name` field with a string value, `tostring` may use that string
-- in its final result.
--
-- For complete control of how numbers are converted, use `string.format`.
function tostring(v) end

---
-- Returns the type of its only argument, coded as a string. The possible results of this
-- function are " `nil`" (a string, not the value nil), "`number`", "`string`", "`boolean`",
-- "`table`", "`function`", "`thread`", and "`userdata`".
function type(v) end

---
-- Returns the elements from the given table. This function is equivalent to return list[i],
-- list[i+1], ···, list[j] except that the above code can be written only for a fixed number
-- of elements. By default, `i` is 1 and `j` is the length of the list, as defined by the length
-- operator (see §2.5.5).
--
-- Deprecated in Lua 5.2.
function unpack(list [, i [, j]]) end

---
-- Emits a warning with a message composed by the concatenation of all its arguments (which
-- should be strings).
--
-- By convention, a one-piece message starting with '`@`' is intended to be a *control message*,
-- which is a message to the warning system itself. In particular, the standard warning function in
-- Lua recognizes the control messages "`@off`", to stop the emission of warnings, and "`@on`",
-- to (re)start the emission; it ignores unknown control messages.
--
-- New in Lua 5.4.
function warn(msg1, ···) end

---
-- This function is similar to `pcall`, except that it sets a new message handler `msgh`.
function xpcall(f, msgh [, arg1, ···]) end

---
-- Closes coroutine `co`, that is, closes all its pending to-be-closed variables and puts the
-- coroutine in a dead state. The given coroutine must be dead or suspended. In case of error
-- closing some variable, returns false plus the error object; otherwise returns true.
function coroutine.close(co) end

---
-- Creates a new coroutine, with body `f`. `f` must be a Lua function. Returns this new coroutine,
-- an object with type `"thread"`.
function coroutine.create(f) end

---
-- Returns true when the coroutine `co` can yield. The default for `co` is the running coroutine.
--
-- A coroutine is yieldable if it is not the main thread and it is not inside a non-yieldable
-- C function.
--
-- New in Lua 5.3.
function coroutine.isyieldable([co]) end

---
-- Starts or continues the execution of coroutine `co`. The first time you resume a coroutine,
-- it starts running its body. The values `val1`, ··· are passed as the arguments to the body
-- function. If the coroutine has yielded, `resume` restarts it; the values `val1`, ··· are
-- passed as the results from the yield.
--
-- If the coroutine runs without any errors, `resume` returns true plus any values passed to
-- `yield` (when the coroutine yields) or any values returned by the body function (when the
-- coroutine terminates). If there is any error, `resume` returns false plus the error message.
function coroutine.resume(co [, val1, ···]) end

---
-- Returns the running coroutine plus a boolean, true when the running coroutine is the main one.
function coroutine.running() end

---
-- Returns the status of the coroutine `co`, as a string: `"running"`, if the coroutine is
-- running (that is, it is the one that called `status`); `"suspended"`, if the coroutine
-- is suspended in a call to `yield`, or if it has not started running yet; `"normal"` if the
-- coroutine is active but not running (that is, it has resumed another coroutine); and `"dead"`
-- if the coroutine has finished its body function, or if it has stopped with an error.
function coroutine.status(co) end

---
-- Creates a new coroutine, with body `f`; `f` must be a Lua function. Returns a function that
-- resumes the coroutine each time it is called. Any arguments passed to this function behave as
-- the extra arguments to `resume`. The function returns the same values returned by `resume`,
-- except the first boolean. In case of error, the function closes the coroutine and propagates
-- the error.
function coroutine.wrap(f) end

---
-- Suspends the execution of the calling coroutine. Any arguments to `yield` are passed as
-- extra results to `resume`.
function coroutine.yield(···) end

---
-- Loads the given module. The function starts by looking into the `package.loaded` table to
-- determine whether `modname` is already loaded. If it is, then `require` returns the value
-- stored at `package.loaded[modname]`. (The absence of a second result in this case signals
-- that this call did not have to load the module.) Otherwise, it tries to find a *loader*
-- for the module.
--
-- To find a loader, `require` is guided by the table `package.searchers`. Each item in this
-- table is a search function, that searches for the module in a particular way. By changing
-- this table, we can change how `require` looks for a module. The following explanation is
-- based on the default configuration for `package.searchers`.
--
-- First `require` queries `package.preload[modname]`. If it has a value, this value (which must be
-- a function) is the loader. Otherwise `require` searches for a Lua loader using the path stored
-- in `package.path`. If that also fails, it searches for a C loader using the path stored in
-- `package.cpath`. If that also fails, it tries an *all-in-one* loader (see `package.searchers`).
--
-- Once a loader is found, `require` calls the loader with two arguments: `modname` and an
-- extra value, a *loader data*, also returned by the searcher. The loader data can be any
-- value useful to the module; for the default searchers, it indicates where the loader
-- was found. (For instance, if the loader came from a file, this extra value is the file
-- path.) If the loader returns any non-nil value, `require` assigns the returned value to
-- `package.loaded[modname]`. If the loader does not return a non-nil value and has not assigned
-- any value to `package.loaded[modname]`, then `require` assigns true to this entry. In any
-- case, `require` returns the final value of `package.loaded[modname]`. Besides that value,
-- `require` also returns as a second result the loader data returned by the searcher, which
-- indicates how `require` found the module.
--
-- If there is any error loading or running the module, or if it cannot find any loader for
-- the module, then `require` raises an error.
function require(modname) end

---
-- Dummy module.
-- @class table
-- @name package
-- @field config (string)
--   A string describing some compile-time configurations for packages. This string is a sequence
--   of lines:
--
--     * The first line is the directory separator string. Default is '`\`' for Windows and
--       '`/`' for all other systems.
--     * The second line is the character that separates templates in a path. Default is '`;`'.
--     * The third line is the string that marks the substitution points in a template. Default
--       is '`?`'.
--     * The fourth line is a string that, in a path in Windows, is replaced by the executable's
--       directory. Default is '`!`'.
--     * The fifth line is a mark to ignore all text after it when building the `luaopen_`
--       function name. Default is '`-`'.
--
--   New in Lua 5.2.
-- @field cpath (string)
--   A string with the path used by `require` to search for a C loader.
--
--   Lua initializes the C path `package.cpath` in the same way it initializes the Lua path
--   `package.path`, using the environment variable `LUA_CPATH_5_4` or the environment variable
--   `LUA_CPATH` or a default path defined in `luaconf.h`.
-- @field loaded (table)
--   A table used by `require` to control which modules are already loaded. When you require
--   a module `modname` and `package.loaded[modname]` is not false, `require` simply returns
--   the value stored there.
--
--   This variable is only a reference to the real table; assignments to this variable do not
--   change the table used by `require`.
-- @field loaders (table)
--   See `package.searchers`.
--
--   Deprecated in Lua 5.2.
-- @field path (string)
--   A string with the path used by `require` to search for a Lua loader.
--
--   At start-up, Lua initializes this variable with the value of the environment variable
--   `LUA_PATH_5_4` or the environment variable `LUA_PATH` or with a default path defined in
--   `luaconf.h`, if those environment variables are not defined. A "`;;`" in the value of the
--   environment variable is replaced by the default path.
-- @field preload (table)
--   A table to store loaders for specific modules (see `require`).
--
--   This variable is only a reference to the real table; assignments to this variable do not
--   change the table used by `require`.
-- @field searchers (table)
--   A table used by `require` to control how to find modules.
--
--   Each entry in this table is a *searcher function*. When looking for a module, `require`
--   calls each of these searchers in ascending order, with the module name (the argument given
--   to `require`) as its sole argument. If the searcher finds the module, it returns another
--   function, the module *loader*, plus an extra value, a *loader data*, that will be passed
--   to that loader and returned as a second result by `require`. If it cannot find the module,
--   it returns a string explaining why (or nil if it has nothing to say).
--
--   Lua initializes this table with four functions.
--
--   The first searcher simply looks for a loader in the `package.preload` table.
--
--   The second searcher looks for a loader as a Lua library, using the path stored at
--   `package.path`. The search is done as described in function `package.searchpath`.
--
--   The third searcher looks for a loader as a C library, using the path given by the variable
--   `package.cpath`. Again, the search is done as described in function `package.searchpath`. For
--   instance, if the C path is the string
--
--     "./?.so;./?.dll;/usr/local/?/init.so"
--
--   the searcher for module `foo` will try to open the files `./foo.so`, `./foo.dll`, and
--   `/usr/local/foo/init.so`, in that order. Once it finds a C library, this searcher first
--   uses a dynamic link facility to link the application with the library. Then it tries to
--   find a C function inside the library to be used as the loader. The name of this C function
--   is the string "`luaopen_`" concatenated with a copy of the module name where each dot
--   is replaced by an underscore. Moreover, if the module name has a hyphen, its suffix after
--   (and including) the first hyphen is removed. For instance, if the module name is `a.b.c-v2.1
--   `, the function name will be `luaopen_a_b_c`.
--
--   The fourth searcher tries an *all-in-one loader*. It searches the C path for a library for
--   the root name of the given module. For instance, when requiring `a.b.c`, it will search for
--   a C library for `a`. If found, it looks into it for an open function for the submodule; in
--   our example, that would be `luaopen_a_b_c`. With this facility, a package can pack several
--   C submodules into one single library, with each submodule keeping its original open function.
--
--   All searchers except the first one (preload) return as the extra value the file path
--   where the module was found, as returned by `package.searchpath`. The first searcher always
--   returns the string "`:preload:`".
--
--   Searchers should raise no errors and have no side effects in Lua. (They may have side
--   effects in C, for instance by linking the application with a library.)
--
--   New in Lua 5.2.
local package

---
-- Dynamically links the host program with the C library `libname`.
--
-- If `funcname` is "`*`", then it only links with the library, making the symbols exported
-- by the library available to other dynamically linked libraries. Otherwise, it looks for
-- a function `funcname` inside the library and returns this function as a C function. So,
-- `funcname` must follow the `lua_CFunction` prototype (see `lua_CFunction`).
--
-- This is a low-level function. It completely bypasses the package and module system. Unlike
-- `require`, it does not perform any path searching and does not automatically adds
-- extensions. `libname` must be the complete file name of the C library, including if necessary
-- a path and an extension. `funcname` must be the exact name exported by the C library (which
-- may depend on the C compiler and linker used).
--
-- This function is not supported by Standard C. As such, it is only available on some platforms
-- (Windows, Linux, Mac OS X, Solaris, BSD, plus other Unix systems that support the `dlfcn`
-- standard).
--
-- This function is inherently insecure, as it allows Lua to call any function in any readable
-- dynamic library in the system. (Lua calls any function assuming the function has a proper
-- prototype and respects a proper protocol (see lua_CFunction). Therefore, calling an arbitrary
-- function in an arbitrary dynamic library more often than not results in an access violation.)
function package.loadlib(libname, funcname) end

---
-- Searches for the given `name` in the given `path`.
--
-- A path is a string containing a sequence of _templates_ separated by semicolons. For each
-- template, the function replaces each interrogation mark (if any) in the template with a copy
-- of `name` wherein all occurrences of `sep` (a dot, by default) were replaced by `rep` (the
-- system's directory separator, by default), and then tries to open the resulting file name.
-- For instance, if the path is the string
--
--   "./?.lua;./?.lc;/usr/local/?/init.lua"
--
-- the search for the name `foo.a` will try to open the files `./foo/a.lua`, `./foo/a.lc`, and
-- `/usr/local/foo/a/init.lua`, in that order.
--
-- Returns the resulting name of the first file that it can open in read mode (after closing
-- the file), or nil plus an error message if none succeeds. (This error message lists all file
-- names it tried to open.)
--
-- New in Lua 5.2.
function package.searchpath(name, path [, sep [, rep]]) end

---
-- Sets a metatable for `module` with its `__index` field referring to the global environment,
-- so that this module inherits values from the global environment. To be used as an option to
-- function `module`.
--
-- Deprecated in Lua 5.2.
function package.seeall(module) end

---
-- Returns the internal numerical codes of the characters `s[i]`, `s[i+1]`, ···, `s[j]`. The
-- default value for `i` is 1; the default value for `j` is `i`. These indices are corrected
-- following the same rules of function `string.sub`.
--
-- Numerical codes are not necessarily portable across platforms.
function string.byte(s [, i [, j]]) end

---
-- Receives zero or more integers. Returns a string with length equal to the number of arguments,
-- in which each character has the internal numerical code equal to its corresponding argument.
--
-- Numerical codes are not necessarily portable across platforms.
function string.char(···) end

---
-- Returns a string containing a binary representation (a _binary chunk_) of the given function, so
-- that a later `load` on this string returns a copy of the function (but with new upvalues). If
-- `strip` is a true value, the binary representation is created without debug information
-- about the function (local variable names, lines, etc.).
--
-- Functions with upvalues have only their number of upvalues saved. When (re)loaded, those
-- upvalues receive fresh instances. (See the `load` function for details about how these
-- upvalues are initialized. You can use the debug library to serialize and reload the upvalues
-- of a function in a way adequate to your needs.)
function string.dump(function [, strip]) end

---
-- Looks for the first match of `pattern` (see §6.4.1) in the string `s`. If it finds a match,
-- then `find` returns the indices of `s` where this occurrence starts and ends; otherwise,
-- it returns nil. A third, optional numerical argument `init` specifies where to start the
-- search; its default value is 1 and can be negative. A value of true as a fourth, optional
-- argument `plain` turns off the pattern matching facilities, so the function does a plain
-- "find substring" operation, with no characters in `pattern` being considered magic.
--
-- If the pattern has captures, then in a successful match the captured values are also returned,
-- after the two indices.
function string.find(s, pattern [, init [, plain]]) end

---
-- Returns a formatted version of its variable number of arguments following the description
-- given in its first argument, which must be a string. The format string follows the same rules
-- as the ISO C function `sprintf`. The only differences are that the conversion specifiers and
-- modifiers `*`, `h`, `L`, `l`, and `n` are not supported and that there is an extra specifier,
-- `q`.
--
-- The specifier `q` formats booleans, nil, numbers, and strings in a way that the result is a
-- valid constant in Lua source code. Booleans and nil are written in the obvious way (`true`,
-- `false`, `nil`). Floats are written in hexadecimal, to preserve full precision. A string is
-- written between double quotes, using escape sequences when necessary to ensure that it can
-- safely be read back by the Lua interpreter. For instance, the call
--
--   string.format('%q', 'a string with "quotes" and \n new line')
--
-- may produce the string:
--
--   "a string with \"quotes\" and \ new line"
--
-- This specifier does not support modifiers (flags, width, length).
--
-- The conversion specifiers `A` and `a` (when available), `E`, `e`, `f`, `G`, and `g` all
-- expect a number as argument. The specifiers `c`, `d`, `i`, `o`, `u`, `X`, and `x` expect an
-- integer. When Lua is compiled with a C89 compiler, the specifiers `A` and `a` (hexadecimal
-- floats) do not support modifiers.
--
-- The specifier `s` expects a string; if its argument is not a string, it is converted to one
-- following the same rules of `tostring`. If the specifier has any modifier, the corresponding
-- string argument should not contain zeros.
--
-- The specifier `p` formats the pointer returned by `lua_topointer`. That gives a unique string
-- identifier for tables, userdata, threads, strings, and functions. For other values (numbers,
-- nil, booleans), this specifier results in a string representing the pointer `NULL`.
function string.format(formatstring, ···) end

---
-- Returns an iterator function that, each time it is called, returns the next captures from
-- `pattern` (see §6.4.1) over the string `s`. If `pattern` specifies no captures, then the
-- whole match is produced in each call. A third, optional argument `init` specifies where to
-- start the search; its default value is 1 and can be negative.
--
-- As an example, the following loop will iterate over all the words from string `s`, printing
-- one per line:
--
--   s = "hello world from Lua" for w in string.gmatch(s, "%a+") do
--     print(w) end
--
-- The next example collects all pairs `key=value` from the given string into a table:
--
--   t = {} s = "from=world, to=Lua" for k, v in string.gmatch(s, "(%w+)=(%w+)") do
--     t[k] = v end
--
-- For this function, a caret '`^`' at the start of a pattern does not work as an anchor,
-- as this would prevent the iteration.
function string.gmatch(s, pattern [, init]) end

---
-- Returns a copy of `s` in which all (or the first `n`, if given) occurrences of the `pattern`
-- (see §6.4.1) have been replaced by a replacement string specified by `repl`, which can be
-- a string, a table, or a function. `gsub` also returns, as its second value, the total number
-- of matches that occurred. The name `gsub` comes from "Global SUBstitution".
--
-- If `repl` is a string, then its value is used for replacement. The character `%` works as an
-- escape character: any sequence in `repl` of the form `%d`, with `d` between 1 and 9, stands
-- for the value of the `d`-th captured substring; the sequence `%0` stands for the whole match;
-- the sequence `%%` stands for a single `%`.
--
-- If `repl` is a table, then the table is queried for every match, using the first capture as
-- the key.
--
-- If `repl` is a function, then this function is called every time a match occurs, with all
-- captured substrings passed as arguments, in order.
--
-- In any case, if the pattern specifies no captures, then it behaves as if the whole pattern
-- was inside a capture.
--
-- If the value returned by the table query or by the function call is a string or a number,
-- then it is used as the replacement string; otherwise, if it is false or nil, then there is
-- no replacement (that is, the original match is kept in the string).
--
-- Here are some examples:
--
--   x = string.gsub("hello world", "(%w+)", "%1 %1") --> x="hello hello world world" x =
--   string.gsub("hello world", "%w+", "%0 %0", 1) --> x="hello hello world" x = string.gsub("hello
--   world from Lua", "(%w+)%s*(%w+)", "%2 %1") --> x="world hello Lua from" x = string.gsub("home
--   = $HOME, user = $USER", "%$(%w+)", os.getenv) --> x="home = /home/roberto, user = roberto"
--   x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s)
--         return load(s)() end)
--   --> x="4+5 = 9" local t = {name="lua", version="5.4"} x = string.gsub("$name-$version.tar.gz",
--   "%$(%w+)", t) --> x="lua-5.4.tar.gz"
function string.gsub(s, pattern, repl [, n]) end

---
-- Receives a string and returns its length. The empty string `""` has length 0. Embedded zeros
-- are counted, so `"a\000bc\000"` has length 5.
function string.len(s) end

---
-- Receives a string and returns a copy of this string with all uppercase letters changed to
-- lowercase. All other characters are left unchanged. The definition of what an uppercase
-- letter is depends on the current locale.
function string.lower(s) end

---
-- Looks for the first *match* of the `pattern` (see §6.4.1) in the string `s`. If it finds one,
-- then `match` returns the captures from the pattern; otherwise it returns nil. If `pattern`
-- specifies no captures, then the whole match is returned. A third, optional numerical argument
-- `init` specifies where to start the search; its default value is 1 and can be negative.
function string.match(s, pattern [, init]) end

---
-- Returns a binary string containing the values `v1`, `v2`, etc. serialized in binary form
-- (packed) according to the format string `fmt` (see §6.4.2).
--
-- New in Lua 5.3.
function string.pack(fmt, v1, v2, ···) end

---
-- Returns the size of a string resulting from `string.pack` with the given format. The format
-- string cannot have the variable-length options 's' or 'z' (see §6.4.2).
--
-- New in Lua 5.3.
function string.packsize(fmt) end

---
-- Returns a string that is the concatenation of `n` copies of the string `s` separated by the
-- string `sep`. The default value for `sep` is the empty string (that is, no separator). Returns
-- the empty string if `n` is not positive.
--
-- (Note that it is very easy to exhaust the memory of your machine with a single call to
-- this function.)
function string.rep(s, n [, sep]) end

---
-- Returns a string that is the string `s` reversed.
function string.reverse(s) end

---
-- Returns the substring of `s` that starts at `i` and continues until `j`; `i` and `j` can
-- be negative. If `j` is absent, then it is assumed to be equal to -1 (which is the same as
-- the string length). In particular, the call `string.sub(s,1,j)` returns a prefix of `s`
-- with length `j`, and `string.sub(s, -i)` returns a suffix of `s` with length `i`.
--
-- If, after the translation of negative indices, `i` is less than 1, it is corrected to 1. If `j`
-- is greater than the string length, it is corrected to that length. If, after these corrections,
-- `i` is greater than `j`, the function returns the empty string.
function string.sub(s, i [, j]) end

---
-- Returns the values packed in string `s` (see `string.pack`) according to the format string
-- `fmt` (see §6.4.2). An optional `pos` marks where to start reading in `s` (default is
-- 1). After the read values, this function also returns the index of the first unread byte in `s`.
--
-- New in Lua 5.3.
function string.unpack(fmt, s [, pos]) end

---
-- Receives a string and returns a copy of this string with all lowercase letters changed to
-- uppercase. All other characters are left unchanged. The definition of what a lowercase letter
-- is depends on the current locale.
function string.upper(s) end

---
-- Dummy table.
-- @class table
-- @name utf8
-- @field charpattern (string)
--   The pattern (a string, not a function) "[\0-\x7F\xC2-\xFD][\x80-\xBF]*" (see §6.4.1), which
--   matches exactly one UTF-8 byte sequence, assuming that the subject is a valid UTF-8 string.
--
--   New in Lua 5.3.

---
-- Receives zero or more integers, converts each one to its corresponding UTF-8 byte sequence
-- and returns a string with the concatenation of all these sequences.
--
-- New in Lua 5.3.
function utf8.char(···) end

---
-- Returns values so that the construction
--
--     for p, c in utf8.codes(s) do *body* end
--
-- will iterate over all UTF-8 characters in string `s`, with `p` being the position (in bytes) and
-- `c` the code point of each character. It raises an error if it meets any invalid byte sequence.
--
-- This function only accepts valid sequences (well formed and not overlong). By default, it only
-- accepts byte sequences that result in valid Unicode code points, rejecting values greater than
-- `10FFFF` and surrogates. The boolean argument `lax` lifts these checks, so that all values
-- up to `0x7FFFFFFF` are accepted. (Not well formed and overlong sequences are still rejected.)
--
-- New in Lua 5.3.
function utf8.codes(s [, lax]) end

---
-- Returns the codepoints (as integers) from all characters in `s` that start between byte
-- position `i` and `j` (both included). The default for `i` is 1 and for `j` is `i`. It raises
-- an error if it meets any invalid byte sequence.
--
-- This function only accepts valid sequences (well formed and not overlong). By default, it only
-- accepts byte sequences that result in valid Unicode code points, rejecting values greater than
-- `10FFFF` and surrogates. The boolean argument `lax` lifts these checks, so that all values
-- up to `0x7FFFFFFF` are accepted. (Not well formed and overlong sequences are still rejected.)
--
-- New in Lua 5.3.
function utf8.codepoint(s [, i [, j [, lax]]]) end

---
-- Returns the number of UTF-8 characters in string `s` that start between positions `i` and `j`
-- (both inclusive). The default for `i` is 1 and for `j` is -1. If it finds any invalid byte
-- sequence, returns nil plus the position of the first invalid byte.
--
-- This function only accepts valid sequences (well formed and not overlong). By default, it only
-- accepts byte sequences that result in valid Unicode code points, rejecting values greater than
-- `10FFFF` and surrogates. The boolean argument `lax` lifts these checks, so that all values
-- up to `0x7FFFFFFF` are accepted. (Not well formed and overlong sequences are still rejected.)
--
-- New in Lua 5.3.
function utf8.len(s [, i [, j [, lax]]]) end

---
-- Returns the position (in bytes) where the encoding of the `n`-th character of `s` (counting
-- from position `i`) starts. A negative `n` gets characters before position `i`. The default
-- for `i` is 1 when `n` is non-negative and `#s + 1` otherwise, so that `utf8.offset(s, -n)`
-- gets the offset of the `n`-th character from the end of the string. If the specified character
-- is neither in the subject nor right after its end, the function returns nil.
--
-- As a special case, when `n` is 0 the function returns the start of the encoding of the
-- character that contains the `i`-th byte of `s`.
--
-- This function assumes that `s` is a valid UTF-8 string.
--
-- New in Lua 5.3.
function utf8.offset(s, n [, i]) end

---
-- Given a list where all elements are strings or numbers, returns the string
-- `list[i]..sep..list[i+1] ··· sep..list[j]`. The default value for `sep` is the empty
-- string, the default for `i` is 1, and the default for `j` is `#list`. If `i` is greater than
-- `j`, returns the empty string.
function table.concat(list [, sep [, i [, j]]]) end

---
-- Inserts element `value` at position `pos` in `list`, shifting up the elements `list[pos],
-- list[pos+1], ···, list[#list]`. The default value for `pos` is `#list+1`, so that a call
-- `table.insert(t,x)` inserts `x` at the end of the list `t`.
function table.insert(list, [pos,] value) end

---
-- Returns the largest positive numerical index of the given table, or zero if the table has
-- no positive numerical indices. (To do its job this function does a linear traversal of the
-- whole table.)
--
-- Deprecated in Lua 5.2.
function table.maxn(table) end

---
-- Moves elements from the table `a1` to the table `a2`, performing the equivalent to the
-- following multiple assignment: `a2[t], ··· = a1[f], ···, a1[e]`. The default for `a2`
-- is `a1`. The destination range can overlap with the source range. Index `f` must be positive.
--
-- Returns the destination table `a2`.
--
-- New in Lua 5.3.
function table.move(a1, f, e, t [,a2]) end

---
-- Returns a new table with all parameters stored into keys 1, 2, etc. and with a field "`n`"
-- with the total number of parameters. Note that the resulting table may not be a sequence,
-- if some arguments are nil.
--
-- New in Lua 5.2.
function table.pack(···) end

---
-- Removes from `list` the element at position `pos`, returning the value of the removed
-- element. When `pos` is an integer between 1 and `#list`, it shifts down the elements
-- `list[pos+1], list[pos+2], ···, list[#list]` and erases element `list[#list]`; The index
-- `pos` can also be 0 when `#list` is 0, or `#list + 1`.
--
-- The default value for `pos` is `#list`, so that a call `table.remove(l)` removes the last
-- element of the list `l`.
function table.remove(list [, pos]) end

---
-- Sorts the list elements in a given order, *in-place*, from `list[1]` to `list[#list]`. If
-- `comp` is given, then it must be a function that receives two list elements and returns true
-- when the first element must come before the second in the final order (so that, after the
-- sort, `i < j` implies `not comp(list[j],list[i])` will be true after the sort). If `comp`
-- is not given, then the standard Lua operator `<` is used instead.
--
-- Note that the `comp` function must not define a string partial order over the elements in the
-- list; that is, it must be asymmetric and transitive. Otherwise, no valid sort may be possible.
--
-- The sort algorithm is not stable; that is, elements not comparable by the given order (e.g.,
-- equal elements) may have their relative positions changed by the sort.
function table.sort(list [, comp]) end

---
-- Returns the elements from the given list. This function is equivalent to
--
--   return list[i], list[i+1], ···, list[j]
--
-- By default, `i` is 1 and `j` is `#list`.
--
-- New in Lua 5.2.
function table.unpack(list [, i [, j]]) end

---
-- Dummy table.
-- @class table
-- @name math
-- @field huge (number)
--   The float value `HUGE_VAL`, a value greater than any other numerical value.
-- @field maxinteger (number)
--   An integer with the maximum value for an integer.
--
--   New in Lua 5.3.
-- @field mininteger (number)
--   An integer with the minimum value for an integer.
--
--   New in Lua 5.3.
-- @field pi (number)
--   The value of 'π'.
local math

---
-- Returns the maximum value between `x` and `-x`. (integer/float)
function math.abs(x) end

---
-- Returns the arc cosine of `x` (in radians).
function math.acos(x) end

---
-- Returns the arc sine of `x` (in radians).
function math.asin(x) end

---
-- Returns the arc tangent of `y/x` (in radians), but uses the signs of both parameters to find
-- the quadrant of the result. It also handles correctly the case of `x` being zero.
--
-- The default value for `x` is 1, so that the call `math.atan(y)` returns the arc tangent of `y`.
function math.atan(y [, x]) end

---
-- Returns the arc tangent of `y/x` (in radians), but uses the signs of both parameters to find
-- the quadrant of the result. (It also handles correctly the case of `x` being zero.)
--
-- Deprecated in Lua 5.3.
function math.atan2(y, x) end

---
-- Returns the smallest integral value greater than or equal to `x`.
function math.ceil(x) end

---
-- Returns the cosine of `x` (assumed to be in radians).
function math.cos(x) end

---
-- Returns the hyperbolic cosine of `x`.
--
-- Deprecated in Lua 5.3.
function math.cosh(x) end

---
-- Converts the angle `x` from radians to degrees.
function math.deg(x) end

---
-- Returns the value *e^x*.
function math.exp(x) end

---
-- Returns the largest integral value less than or equal to `x`.
function math.floor(x) end

---
-- Returns the remainder of the division of `x` by `y` that rounds the quotient towards
-- zero. (integer/float)
function math.fmod(x, y) end

---
-- Returns `m` and `e` such that 'x = m2^e', `e` is an integer and the absolute value of `m`
-- is in the range *[0.5, 1)* (or zero when `x` is zero).
--
-- Deprecated in Lua 5.3.
function math.frexp(x) end

---
-- Returns 'm2^e' (`e` should be an integer).
--
-- Deprecated in Lua 5.3.
function math.ldexp(m, e) end

---
-- Returns the logarithm of `x` in the given base. The default for `base` is 'e' (so that the
-- function returns the natural logarithm of `x`).
function math.log(x [, base]) end

---
-- Returns the base-10 logarithm of `x`.
--
-- Deprecated in Lua 5.2.
function math.log10(x) end

---
-- Returns the argument with the maximum value, according to the Lua operator `<`.
function math.max(x, ···) end

---
-- Returns the argument with the minimum value, according to the Lua operator `<`.
function math.min(x, ···) end

---
-- Returns the integral part of `x` and the fractional part of `x`. Its second result is always
-- a float.
function math.modf(x) end

---
-- Returns *x^y*. (You can also use the expression `x^y` to compute this value.)
--
-- Deprecated in Lua 5.3.
function math.pow(x, y) end

---
-- Converts the angle `x` from degrees to radians.
function math.rad(x) end

---
-- When called without arguments, returns a pseudo-random float with uniform distribution in the
-- range [0,1). When called with two integers `m` and `n`, `math.random` returns a pseudo-random
-- integer with uniform distribution in the range `[m, n]. The call `math.random(n)`, for a
-- positive `n`, is equivalent to `math.random(1,n)`. The call `math.random(0)` produces an
-- integer with all bits (pseudo)random.
--
-- This function uses the `xoshiro256**` algorithm to produce pseudo-random 64-bit integers,
-- which are the results of calls with argument 0. Other results (ranges and floats) are unbiased
-- extracted from these integers.
--
-- Lua initializes its pseudo-random generator with the equivalent of a call to `math.randomseed`
-- with no arguments, so that `math.random` should generate different sequences of results each
-- time the program runs.
function math.random([m [, n]]) end

---
-- When called with at least one argument, the integer parameters `x` and `y` are joined into a
-- 128-bit *seed* that is used to reinitialize the pseudo-random generator; equal seeds produce
-- equal sequences of numbers. The default for `y` is zero.
--
-- When called with no arguments, Lua generates a seed with a weak attempt for randomness.
--
-- This function returns the two seed components that were effectively used, so that setting
-- them again repeats the sequence.
--
-- To ensure a required level of randomness to the initial state (or contrarily, to have
-- a deterministic sequence, for instance when debugging a program), you should call
-- `math.randomseed` with explicit arguments.
function math.randomseed([x [, y]]) end

---
-- Returns the sine of `x` (assumed to be in radians).
function math.sin(x) end

---
-- Returns the hyperbolic sine of `x`.
--
-- Deprecated in Lua 5.3.
function math.sinh(x) end

---
-- Returns the square root of `x`. (You can also use the expression `x^0.5` to compute this value.)
function math.sqrt(x) end

---
-- Returns the tangent of `x` (assumed to be in radians).
function math.tan(x) end

---
-- Returns the hyperbolic tangent of `x`.
--
-- Deprecated in Lua 5.3.
function math.tanh(x) end

---
-- If the value `x` is convertible to an integer, returns that integer. Otherwise, returns nil.
--
-- New in Lua 5.3.
function math.tointeger(x) end

---
-- Returns "integer" if `x` is an integer, "float" if it is a float, or nil if x is not a number.
--
-- New in Lua 5.3.
function math.type(x) end

---
-- Returns a boolean, true if integer `m` is below integer `n` when they are compared as
-- unsigned integers.
--
-- New in Lua 5.3.
function math.ult(m, n) end

---
-- Returns the number `x` shifted `disp` bits to the right. The number `disp` may be any
-- representable integer. Negative displacements shift to the left.
--
-- This shift operation is what is called arithmetic shift. Vacant bits on the left are filled
-- with copies of the higher bit of `x`; vacant bits on the right are filled with zeros. In
-- particular, displacements with absolute values higher than 31 result in zero or `0xFFFFFFFF`
-- (all original bits are shifted out).
--
-- New in Lua 5.2. Deprecated in Lua 5.3.
function bit32.arshift(x, disp) end

---
-- Returns the bitwise "and" of its operands.
--
-- New in Lua 5.2. Deprecated in Lua 5.3.
function bit32.band(...) end

---
-- Returns the bitwise negation of `x`. For any integer `x`, the following identity holds:
--
--   assert(bit32.bnot(x) == (-1 - x) % 2^32)
--
-- New in Lua 5.2. Deprecated in Lua 5.3.
function bit32.bnot(x) end

---
-- Returns the bitwise "or" of its operands.
--
-- New in Lua 5.2. Deprecated in Lua 5.3.
function bit32.bor(...) end

---
-- Returns a boolean signaling whether the bitwise "and" of its operands is different from zero.
--
-- New in Lua 5.2. Deprecated in Lua 5.3.
function bit32.btest(...) end

---
-- Returns the bitwise "exclusive or" of its operands.
--
-- New in Lua 5.2. Deprecated in Lua 5.3.
function bit32.xor(...) end

---
-- Returns the unsigned number formed by the bits `field` to `field + width - 1` from `n`. Bits
-- are numbered from 0 (least significant) to 31 (most significant). All accessed bits must be
-- in the range [0, 31].
--
-- The default for `width` is 1.
--
-- New in Lua 5.2. Deprecated in Lua 5.3.
function bit32.extract(n, field [, width]) end

---
-- Returns a copy of `n` with the bits `field` to `field + width - 1` replaced by the value
-- `v`. See `bit32.extract` for details about `field` and `width`.
--
-- New in Lua 5.2. Deprecated in Lua 5.3.
function bit32.replace(n, v, field [, width]) end

---
-- Returns the number `x` rotated `disp` bits to the left. The number `disp` may be any
-- representable integer.
--
-- For any valid displacement, the following identity holds:
--
--   assert(bit32.lrotate(x, disp) == bit32.lrotate(x, disp % 32))
--
-- In particular, negative displacements rotate to the right.
--
-- New in Lua 5.2. Deprecated in Lua 5.3.
function bit32.lrotate(x, disp) end

---
-- Returns the number `x` shifted `disp` bits to the left. The number `disp` may be any
-- representable integer. Negative displacements shift to the right. In any direction, vacant
-- bits are filled with zeros. In particular, displacements with absolute values higher than
-- 31 result in zero (all bits are shifted out).
--
-- For positive displacements, the following equality holds:
--
--   assert(bit32.lshift(b, disp) == (b * 2^disp) % 2^32)
--
-- New in Lua 5.2. Deprecated in Lua 5.3.
function bit32.lshift(x, disp) end

---
-- Returns the number `x` rotated `disp` bits to the right. The number `disp` may be any
-- representable integer.
--
-- For any valid displacement, the following identity holds:
--
--   assert(bit32.rrotate(x, disp) == bit32.rrotate(x, disp % 32))
--
-- In particular, negative displacements rotate to the left.
--
-- New in Lua 5.2. Deprecated in Lua 5.3.
function bit32.rrotate(x, disp) end

---
-- Returns the number `x` shifted `disp` bits to the right. The number `disp` may be any
-- representable integer. Negative displacements shift to the left. In any direction, vacant
-- bits are filled with zeros. In particular, displacements with absolute values higher than
-- 31 result in zero (all bits are shifted out).
--
-- For positive displacements, the following equality holds:
--
--   assert(bit32.rshift(b, disp) == math.floor(b % 2^32 / 2^disp))
--
-- This shift operation is what is called logical shift.
--
-- New in Lua 5.2. Deprecated in Lua 5.3.
function bit32.rshift(x, disp) end

---
-- Dummy table.
-- @class table
-- @name io
-- @field stderr (file)
--   Standard error.
-- @field stdin (file)
--   Standard in.
-- @field stdout (file)
--   Standard out.
local io

---
-- Equivalent to `file:close()`. Without a `file`, closes the default output file.
function io.close([file]) end

---
-- Equivalent to `io.output():flush()`.
function io.flush() end

---
-- When called with a file name, it opens the named file (in text mode), and sets its handle as
-- the default input file. When called with a file handle, it simply sets this file handle as the
-- default input file. When called without parameters, it returns the current default input file.
--
-- In case of errors this function raises the error, instead of returning an error code.
function io.input([file]) end

---
-- Opens the given file name in read mode and returns an iterator function that works like
-- `file:lines(···)` over the opened file. When the iterator function fails to read any value,
-- it automatically closes the file. Besides the iterator function, `io.lines` returns three other
-- values: two nil values as placeholders, plus the created file handle. Therefore, when used in
-- a generic for loop, the file is closed also if the loop is interrupted by an error or a `break`.
--
-- The call `io.lines()` (with no file name) is equivalent to `io.input():lines("l")`; that is,
-- it iterates over the lines of the default input file. In this case it does not close the
-- file when the loop ends.
--
-- In case of errors opening the file, this function raises the error, instead of returning an
-- error code.
function io.lines([filename, ···]) end

---
-- This function opens a file, in the mode specified in the string `mode`. It returns a new
-- file handle, or, in case of errors, nil plus an error message.
--
-- The `mode` string can be any of the following:
--
--   * "r": read mode (the default);
--   * "w": write mode;
--   * "a": append mode;
--   * "r+": update mode, all previous data is preserved;
--   * "w+": update mode, all previous data is erased;
--   * "a+": append update mode, previous data is preserved, writing is only allowed at the
--     end of file.
--
-- The `mode` string can also have a '`b`' at the end, which is needed in some systems to open
-- the file in binary mode.
function io.open(filename [, mode]) end

---
-- Similar to `io.input`, but operates over the default output file.
function io.output([file]) end

---
-- Starts the program `prog` in a separated process and returns a file handle that you can use
-- to read data from this program (if `mode` is `"r"`, the default) or to write data to this
-- program (if `mode` is `"w"`).
--
-- This function is system dependent and is not available on all platforms.
function io.popen(prog [, mode]) end

---
-- Equivalent to `io.input():read(···)`.
function io.read(···) end

---
-- In case of success, returns a handle for a temporary file. This file is opened in update
-- mode and it is automatically removed when the program ends.
function io.tmpfile() end

---
-- Checks whether `obj` is a valid file handle. Returns the string `"file"` if `obj` is an
-- open file handle, `"closed file"` if `obj` is a closed file handle, or nil if `obj` is not
-- a file handle.
function io.type(obj) end

---
-- Equivalent to `io.output():write(···)`.
function io.write(···) end

---
-- Closes `file`. Note that files are automatically closed when their handles are garbage
-- collected, but that takes an unpredictable amount of time to happen.
--
-- When closing a file handle created with `io.popen`, `file:close` returns the same values
-- returned by `os.execute`.
function file:close() end

---
-- Saves any written data to `file`.
function file:flush() end

---
-- Returns an iterator function that, each time it is called, reads the file according to the
-- given formats. When no format is given, uses "l" as a default. As an example, the construction
--
--   for c in file:lines(1) do *body* end
--
-- will iterate over all characters of the file, starting at the current position. Unlike
-- `io.lines`, this function does not close the file when the loop ends.
function file:lines(···) end

---
-- Reads the file `file`, according to the given formats, which specify what to read. For each
-- format, the function returns a string or a number with the characters read, or nil if it
-- cannot read data with the specified format. (In this latter case, the function does not read
-- subsequent formats.)  When called without arguments, it uses a default format that reads
-- the next line (see below).
--
-- The available formats are
--
--   * "n": reads a numeral and returns it as a float or an integer, following the lexical
--     conventions of Lua. (The numeral may have leading whitespaces and a sign.) This format
--     always reads the longest input sequence that is a valid prefix for a number; if that
--     prefix does not form a valid number (e.g., an empty string, "0x", or "3.4e-") or it is
--     too long (more than 200 characters), it is discarded and the format returns nil.
--   * "a": reads the whole file, starting at the current position. On end of file, it returns
--     the empty string; this format never fails.
--   * "l": reads the next line skipping the end of line, returning nil on end of file. This
--     is the default format.
--   * "L": reads the next line keeping the end-of-line character (if present), returning nil
--     on end of file.
--   * *number*: reads a string with up to this number of bytes, returning nil on end of file. If
--     *number* is zero, it reads nothing and returns an empty string, or nil on end of file.
--
-- The formats "l" and "L" should be used only for text files.
function file:read(···) end

---
-- Sets and gets the file position, measured from the beginning of the file, to the position
-- given by `offset` plus a base specified by the string `whence`, as follows:
--
--   * "set": base is position 0 (beginning of the file);
--   * "cur": base is current position;
--   * "end": base is end of file;
--
-- In case of success, function `seek` returns the final file position, measured in bytes from
-- the beginning of the file. If `seek` fails, it returns nil, plus a string describing the error.
--
-- The default value for `whence` is `"cur"`, and for `offset` is 0. Therefore, the
-- call `file:seek()` returns the current file position, without changing it; the call
-- `file:seek("set")` sets the position to the beginning of the file (and returns 0); and the
-- call `file:seek("end")` sets the position to the end of the file, and returns its size.
function file:seek([whence [, offset]]) end

---
-- Sets the buffering mode for a file. There are three available modes:
--
--   * "no": no buffering
--   * "full": full buffering
--   * "line": line buffering
--
-- For the last two cases, `size` is a hint for the size of the buffer, in bytes. The default
-- is an appropriate size.
--
-- The specific behavior of each mode is non portable; check the underlying ISO C function
-- `setvbuf` in your platform for more details.
function file:setvbuf(mode [, size]) end

---
-- Writes the value of each of its arguments to `file`. The arguments must be strings or numbers.
--
-- In case of success, this function returns `file`. Otherwise it returns nil plus a string
-- describing the error.
function file:write(···) end

---
-- Returns an approximation of the amount in seconds of CPU time used by the program, as returned
-- by the underlying ISO C function `clock`.
function os.clock() end

---
-- Returns a string or a table containing date and time, formatted according to the given string
-- `format`.
--
-- If the `time` argument is present, this is the time to be formatted (see the `os.time`
-- function for a description of this value). Otherwise, `date` formats the current time.
--
-- If `format` starts with '`!`', then the date is formatted in Coordinated Universal Time. After
-- this optional character, if `format` is the string "`*t`", then `date` returns a table with
-- the following fields: `year`, `month` (1-12), `day` (1-31), `hour` (0-23), `min` (0-59),
-- `sec` (0-61, due to leap seconds), `wday` (weekday, 1-7, Sunday is 1), `yday` (day of the
-- year, 1-366), and `isdst` (daylight saving flag, a boolean). This last field may be absent
-- if the information is not available.
--
-- If `format` is not "`*t`", then `date` returns the date as a string, formatted according to
-- the same rules as the ISO C function `strftime`.
--
-- If `format` is absent, it defaults to "`%c`", which gives a human-readable date and time
-- representation using the current locale.
--
-- On non-POSIX systems, this function may be not thread safe because of its reliance on C
-- function `gmtime` and C function `localtime`.
function os.date([format [, time]]) end

---
-- Returns the difference, in seconds, from time `t1` to time `t2` (where the times are values
-- returned by `os.time`). In POSIX, Windows, and some other systems, this value is exactly
-- `t2`*-*`t1`.
function os.difftime(t2, t1) end

---
-- This function is equivalent to the ISO C function `system`. It passes `command` to be
-- executed by an operating system shell. Its first result is `true` if the command terminated
-- successfully, or `nil` otherwise. After this first result the function returns a string plus
-- a number, as follows:
--
--   * "exit": the command terminated normally; the following number is the exit status of
--     the command.
--   * "signal": the command was terminated by a signal; the following number is the signal
--     that terminated the command.
--
-- When called without a `command`, `os.execute` returns a boolean that is true if a shell
-- is available.
function os.execute([command]) end

---
-- Calls the ISO C function `exit` to terminate the host program. If `code` is `true`, the returned
-- status is `EXIT_SUCCESS`; if `code` is `false`, the returned status is `EXIT_FAILURE`; if
-- `code` is a number, the returned status is this number. The default value for `code` is `true`.
--
-- If the optional second argument `close` is true, closes the Lua state before exiting.
function os.exit([code [, close]]) end

---
-- Returns the value of the process environment variable `varname`, or nil if the variable is
-- not defined.
function os.getenv(varname) end

---
-- Deletes the file (or empty directory, on POSIX systems) with the given name. If this function
-- fails, it returns nil, plus a string describing the error and the error code.
function os.remove(filename) end

---
-- Renames file or directory named `oldname` to `newname`. If this function fails, it returns
-- nil, plus a string describing the error and the error code.
function os.rename(oldname, newname) end

---
-- Sets the current locale of the program. `locale` is a system-dependent string specifying
-- a locale; `category` is an optional string describing which category to change: `"all"`,
-- `"collate"`, `"ctype"`, `"monetary"`, `"numeric"`, or `"time"`; the default category is
-- `"all"`. The function returns the name of the new locale, or nil if the request cannot
-- be honored.
--
-- If `locale` is the empty string, the current locale is set to an implementation-defined native
-- locale. If `locale` is the string "`C`", the current locale is set to the standard C locale.
--
-- When called with nil as the first argument, this function only returns the name of the
-- current locale for the given category.
--
-- This function may not be thread safe because of its reliance on C function `setlocale`.
function os.setlocale(locale [, category]) end

---
-- Returns the current time when called without arguments, or a time representing the date and
-- time specified by the given table. This table must have fields `year`, `month`, and `day`,
-- and may have fields `hour` (default is 12), `min` (default is 0), `sec` (default is 0), and
-- `isdst` (default is nil). For a description of these fields, see the `os.date` function.
--
-- When the function is called, the values in these fields do not need to be inside their
-- valid ranges. For instance, if `sec` is -10, it means 10 seconds before the time specified
-- by the other fields; if `hour` is 1000, it means 1000 hours after the time specified by the
-- other fields.
--
-- The returned value is a number, whose meaning depends on your system. In POSIX, Windows,
-- and some other systems, this number counts the number of seconds since some given start time
-- (the "epoch"). In other systems, the meaning is not specified, and the number returned by
-- `time` can be used only as an argument to `os.date` and `os.difftime`.
--
-- When called with a table, `os.time` also normalizes all the fields documented in the `os.date`
-- function, so that they represent the same time as before the call but with values inside
-- their valid ranges.
function os.time([table]) end

---
-- Returns a string with a file name that can be used for a temporary file. The file must be
-- explicitly opened before its use and explicitly removed when no longer needed.
--
-- On POSIX systems, this function also creates a file with that name, to avoid security
-- risks. (Someone else might create the file with wrong permissions in the time between getting
-- the name and creating the file.) You still have to open the file to use it and to remove it
-- (even if you do not use it).
--
-- When possible, you may prefer to use `io.tmpfile`, which automatically removes the file when
-- the program ends.
function os.tmpname() end

---
-- Enters an interactive mode with the user, running each string that the user enters. Using
-- simple commands and other debug facilities, the user can inspect global and local variables,
-- change their values, evaluate expressions, and so on. A line containing only the word `cont`
-- finishes this function, so that the caller continues its execution.
--
-- Note that commands for `debug.debug` are not lexically nested within any function and so
-- have no direct access to local variables.
function debug.debug() end

---
-- Returns the environment of object `o`.
--
-- Deprecated in Lua 5.2.
function debug.getfenv(o) end

---
-- Returns the current hook settings of the thread, as three values: the current hook function,
-- the current hook mask, and the current hook count, as set by the `debug.sethook` function.
--
-- Returns nil if there is no active hook.
function debug.gethook([thread]) end

---
-- Returns a table with information about a function. You can give the function directly or
-- you can give a number as the value of `f`, which means the function running at level `f`
-- of the call stack of the given thread: level 0 is the current function (`getinfo` itself);
-- level 1 is the function that called `getinfo` (except for tail calls, which do not count in
-- the stack); and so on. If `f` is a number greater than the number of active functions, then
-- `getinfo` returns nil.
--
-- The returned table can contain all the fields returned by `lua_getinfo`, with the string
-- `what` describing which fields to fill in. The default for `what` is to get all information
-- available, except the table of valid lines. If present, the option '`f`' adds a field named
-- `func` with the function itself. If present, the option '`L`' adds a field named `activelines`
-- with the table of valid lines.
--
-- For instance, the expression `debug.getinfo(1,"n").name` returns a table with a name for the
-- current function, if a reasonable name can be found, and the expression `debug.getinfo(print)`
-- returns a table with all available information about the `print` function.
function debug.getinfo([thread,] f [, what]) end

---
-- This function returns the name and the value of the local variable with index `local` of the
-- function at level `f` of the stack. This function accesses not only explicit local variables,
-- but also parameters and temporary values.
--
-- The first parameter or local variable has index 1, and so on, following the order that
-- they are declared in the code, counting only the variables that are active in the current
-- scope of the function. Compile-time constants may not appear in this listing, if they were
-- optimized away by the compiler. Negative indices refer to vararg parameters; -1 is the first
-- vararg parameter. The function returns nil if there is no variable with the given index,
-- and raises an error when called with a level out of range. (You can call `debug.getinfo`
-- to check whether the level is valid.)
--
-- Variable names starting with '(' (open parenthesis) represent variables with no known names
-- (internal variables such as loop control variables, and variables from chunks saved without
-- debug information).
--
-- The parameter `f` may also be a function. In that case, `getlocal` returns only the name of
-- function parameters.
function debug.getlocal([thread,] f, local) end

---
-- Returns the metatable of the given `value` or nil if it does not have a metatable.
function debug.getmetatable(value) end

---
-- Returns the registry table (see §4.3).
function debug.getregistry() end

---
-- This function returns the name and the value of the upvalue with index `up` of the function
-- `f`. The function returns nil if there is no upvalue with the given index.
--
-- (For Lua functions, upvalues are the external local variables that the function uses, and
-- that are consequently included in its closure.)
--
-- For C functions, this function uses the empty string `""` as a name for all upvalues.
--
-- Variable name '`?`' (interrogation mark) represents variables with no known names (variables
-- from chunks saved without debug information).
function debug.getupvalue(f, up) end

---
-- Returns the `n`-th user value associated to the userdata `u` plus a boolean, false, if the
-- userdata does not have that value.
--
-- New in Lua 5.2.
function debug.getuservalue(u, n) end

---
-- Sets the environment of the given `object` to the given `table`. Returns `object`.
--
-- Deprecated in Lua 5.2.
function debug.setfenv(object, table) end

---
-- Sets the given function as the debug hook. The string `mask` and the number `count` describe
-- when the hook will be called. The string mask may have any combination of the following
-- characters, with the given meaning:
--
--   * "c": the hook is called every time Lua calls a function;
--   * "r": the hook is called every time Lua returns from a function;
--   * "l": the hook is called every time Lua enters a new line of code.
--
-- Moreover, with a `count` different from zero, the hook is called also after every `count`
-- instructions.
--
-- When called without arguments, `debug.sethook` turns off the hook.
--
-- When the hook is called, its first parameter is a string describing the event that has
-- triggered its call: `"call"`, `"tail call"`, `"return"`, `"line"`, and `"count"`. For line
-- events, the hook also gets the new line number as its second parameter. Inside a hook, you
-- can call `getinfo` with level 2 to get more information about the running function. (Level
-- 0 is the `getinfo` function, and level 1 is the hook function.)
function debug.sethook([thread,] hook, mask [, count]) end

---
-- This function assigns the value `value` to the local variable with index `local` of the
-- function at level `level` of the stack. The function returns nil if there is no local variable
-- with the given index, and raises an error when called with a `level` out of range. (You can
-- call `getinfo` to check whether the level is valid.) Otherwise, it returns the name of the
-- local variable.
--
-- See `debug.getlocal` for more information about variable indices and names.
function debug.setlocal([thread,] level, local, value) end

---
-- Sets the metatable for the given `value` to the given `table` (which can be nil).
function debug.setmetatable(value, table) end

---
-- This function assigns the value `value` to the upvalue with index `up` of the function
-- `f`. The function returns nil if there is no upvalue with the given index. Otherwise, it
-- returns the name of the upvalue.
--
-- See `debug.getupvalue` for more information about upvalues.
function debug.setupvalue(f, up, value) end

---
-- Sets the given `value` as the `n`-th user value associated to the given `udata`. `udata`
-- must be a full userdata.
--
-- Returns `udata`, or nil if the userdata does not have that value.
--
-- New in Lua 5.2.
function debug.setuservalue(udata, value, n) end

---
-- If `message` is present but is neither a string nor nil, this function returns `message`
-- without further processing. Otherwise, it returns a string with a traceback of the call
-- stack. The optional `message` string is appended at the beginning of the traceback. An optional
-- `level` number tells at which level to start the traceback (default is 1, the function calling
-- `traceback`).
function debug.traceback([thread,] [message] [,level]) end

---
-- Returns a unique identifier (as a light userdata) for the upvalue numbered `n` from the
-- given function.
--
-- These unique identifiers allow a program to check whether different closures share upvalues. Lua
-- closures that share an upvalue (that is, that access a same external local variable) will
-- return identical ids for those upvalue indices.
--
-- New in Lua 5.2.
function debug.upvalueid(f, n) end

---
-- Make the `n1`-th upvalue of the Lua closure `f1` refer to the `n2`-th upvalue of the Lua
-- closure `f2`.
--
-- New in Lua 5.2.
function debug.upvaluejoin(f1, n1, f2, n2) end

-- External libraries.

-- LPeg.

---
-- The matching function. It attempts to match the given pattern against the subject string. If
-- the match succeeds, returns the index in the subject of the first character after the match,
-- or the captured values (if the pattern captured any value).
--
-- An optional numeric argument `init` makes the match start at that position in the subject
-- string. As usual in Lua libraries, a negative value counts from the end.
--
-- Unlike typical pattern-matching functions, match works only in anchored mode; that is, it
-- tries to match the pattern with a prefix of the given subject string (at position `init`),
-- not with an arbitrary substring of the subject. So, if we want to find a pattern anywhere in
-- a string, we must either write a loop in Lua or write a pattern that matches anywhere. This
-- second approach is easy and quite efficient; see examples.
function lpeg.match(pattern, subject [, init]) end

---
-- If the given value is a pattern, returns the string "pattern". Otherwise returns nil.
function lpeg.type(value) end

---
-- Returns a string with the running version of LPeg.
function lpeg.version() end

---
-- Sets the maximum size for the backtrack stack used by LPeg to track calls and choices. Most
-- well-written patterns need little backtrack levels and therefore you seldom need to change
-- this maximum; but a few useful patterns may need more space. Before changing this maximum
-- you should try to rewrite your pattern to avoid the need for extra space.
function lpeg.setmaxstack(max) end

---
-- Converts the given value into a proper pattern, according to the following rules:
--
--   * If the argument is a pattern, it is returned unmodified.
--   * If the argument is a string, it is translated to a pattern that matches the string
--     literally.
--   * If the argument is a non-negative number n, the result is a pattern that matches exactly
--     n characters.
--   * If the argument is a negative number -n, the result is a pattern that succeeds only if the
--     input string has less than n characters left: `lpeg.P(-n)` is equivalent to `-lpeg.P(n)`
--     (see the unary minus operation).
--   * If the argument is a boolean, the result is a pattern that always succeeds or always fails
--     (according to the boolean value), without consuming any input.
--   * If the argument is a table, it is interpreted as a grammar (see Grammars).
--   * If the argument is a function, returns a pattern equivalent to a match-time capture over
--     the empty string.
function lpeg.P(value) end

---
-- Returns a pattern that matches only if the input string at the current position is preceded
-- by `patt`. Pattern `patt` must match only strings with some fixed length, and it cannot
-- contain captures.
--
-- Like the and predicate, this pattern never consumes any input, independently of success
-- or failure.
function lpeg.B(patt) end

---
-- Returns a pattern that matches any single character belonging to one of the given ranges. Each
-- `range` is a string xy of length 2, representing all characters with code between the codes
-- of x and y (both inclusive).
--
-- As an example, the pattern `lpeg.R("09")` matches any digit, and `lpeg.R("az", "AZ")`
-- matches any ASCII letter.
function lpeg.R({range}) end

---
-- Returns a pattern that matches any single character that appears in the given string. (The
-- S stands for Set.)
--
-- As an example, the pattern `lpeg.S("+-*/")` matches any arithmetic operator.
--
-- Note that, if `s` is a character (that is, a string of length 1), then `lpeg.P(s)` is equivalent
-- to `lpeg.S(s)` which is equivalent to `lpeg.R(s..s)`. Note also that both `lpeg.S("")` and
-- `lpeg.R()` are patterns that always fail.
function lpeg.S(string) end

---
-- This operation creates a non-terminal (a variable) for a grammar. The created non-terminal
-- refers to the rule indexed by `v` in the enclosing grammar. (See Grammars for details.)
function lpeg.V(v) end

---
-- Returns a table with patterns for matching some character classes according to the current
-- locale. The table has fields named `alnum`, `alpha`, `cntrl`, `digit`, `graph`, `lower`,
-- `print`, `punct`, `space`, `upper`, and `xdigit`, each one containing a correspondent
-- pattern. Each pattern matches any single character that belongs to its class.
--
-- If called with an argument `table`, then it creates those fields inside the given table and
-- returns that table.
function lpeg.locale([table]) end

---
-- Creates a simple capture, which captures the substring of the subject that matches `patt`. The
-- captured value is a string. If `patt` has other captures, their values are returned after
-- this one.
function lpeg.C(patt) end

---
-- Creates an argument capture. This pattern matches the empty string and produces the value
-- given as the nth extra argument given in the call to `lpeg.match`.
function lpeg.Carg(n) end

---
-- Creates a back capture. This pattern matches the empty string and produces the values produced
-- by the most recent group capture named `name`.
--
-- Most recent means the last complete outermost group capture with the given name. A Complete
-- capture means that the entire pattern corresponding to the capture has matched. An Outermost
-- capture means that the capture is not inside another complete capture.
--
-- In the same way that LPeg does not specify when it evaluates captures, it does not specify
-- whether it reuses values previously produced by the group or re-evaluates them.
function lpeg.Cb(name) end

---
-- Creates a constant capture. This pattern matches the empty string and produces all given
-- values as its captured values.
function lpeg.Cc([value, ...]) end

---
-- Creates a fold capture. If patt produces a list of captures C1 C2 ... Cn, this capture will
-- produce the value func(...func(func(C1, C2), C3)..., Cn), that is, it will fold (or accumulate,
-- or reduce) the captures from `patt` using function `func`.
--
-- This capture assumes that `patt` should produce at least one capture with at least one value
-- (of any type), which becomes the initial value of an accumulator. (If you need a specific
-- initial value, you may prefix a constant capture to `patt`.) For each subsequent capture,
-- LPeg calls `func` with this accumulator as the first argument and all values produced by
-- the capture as extra arguments; the first result from this call becomes the new value for
-- the accumulator. The final value of the accumulator becomes the captured value.
--
-- As an example, the following pattern matches a list of numbers separated by commas and
-- returns their addition:
--
--   -- matches a numeral and captures its numerical value
--   number = lpeg.R"09"^1 / tonumber
--   -- matches a list of numbers, capturing their values
--   list = number * ("," * number)^0
--   -- auxiliary function to add two numbers
--   function add (acc, newvalue) return acc + newvalue end
--   -- folds the list of numbers adding them
--   sum = lpeg.Cf(list, add)
--   -- example of use
--   print(sum:match("10,30,43"))   --> 83
function lpeg.Cf(patt, func) end

---
-- Creates a group capture. It groups all values returned by `patt` into a single capture. The
-- group may be anonymous (if no name is given) or named with the given name.
--
-- An anonymous group serves to join values from several captures into a single capture. A named
-- group has a different behavior. In most situations, a named group returns no values at all. Its
-- values are only relevant for a following back capture or when used inside a table capture.
function lpeg.Cg(patt [, name]) end

---
-- Creates a position capture. It matches the empty string and captures the position in the
-- subject where the match occurs. The captured value is a number.
function lpeg.Cp() end

---
-- Creates a substitution capture, which captures the substring of the subject that matches
-- `patt`, with substitutions. For any capture inside `patt` with a value, the substring that
-- matched the capture is replaced by the capture value (which should be a string). The final
-- captured value is the string resulting from all replacements.
function lpeg.Cs(patt) end

---
-- Creates a table capture. This capture returns a table with all values from all anonymous
-- captures made by `patt` inside this table in successive integer keys, starting at 1. Moreover,
-- for each named capture group created by `patt`, the first value of the group is put into
-- the table with the group name as its key. The captured value is only the table.
function lpeg.Ct(patt) end

---
-- Creates a match-time capture. Unlike all other captures, this one is evaluated immediately
-- when a match occurs (even if it is part of a larger pattern that fails later). It forces
-- the immediate evaluation of all its nested captures and then calls `function`.
--
-- The given function gets as arguments the entire subject, the current position (after the
-- match of `patt`), plus any capture values produced by `patt`.
--
-- The first value returned by `function` defines how the match happens. If the call returns a
-- number, the match succeeds and the returned number becomes the new current position. (Assuming
-- a subject s and current position i, the returned number must be in the range [i, len(s) +
-- 1].) If the call returns true, the match succeeds without consuming any input. (So, to return
-- true is equivalent to return i.) If the call returns false, nil, or no value, the match fails.
--
-- Any extra values returned by the function become the values produced by the capture.
function lpeg.Cmt(patt, function) end

-- LuaFileSystem.

---
-- Returns a table with the file attributes corresponding to filepath (or nil followed by
-- an error message in case of error). If the second optional argument is given and is a
-- string, then only the value of the named attribute is returned (this use is equivalent to
-- lfs.attributes(filepath)[aname], but the table is not created and only one attribute is
-- retrieved from the O.S.). If a table is passed as the second argument, it is filled with
-- attributes and returned instead of a new table. The attributes are described as follows;
-- attribute mode is a string, all the others are numbers, and the time related attributes use
-- the same time reference of os.time:
--
--   dev: on Unix systems, this represents the device that the inode resides on. On Windows
--     systems, represents the drive number of the disk containing the file
--   ino: on Unix systems, this represents the inode number. On Windows systems this has no meaning
--   mode: string representing the associated protection mode (the values could be file,
--     directory, link, socket, named pipe, char device, block device or other)
--   nlink: number of hard links to the file
--   uid: user-id of owner (Unix only, always 0 on Windows)
--   gid: group-id of owner (Unix only, always 0 on Windows)
--   rdev: on Unix systems, represents the device type, for special file inodes. On Windows
--     systems represents the same as dev
--   access: time of last access
--   modification: time of last data modification
--   change: time of last file status change
--   size: file size, in bytes
--   permissions: file permissions string
--   blocks: block allocated for file; (Unix only)
--   blksize: optimal file system I/O blocksize; (Unix only)
--
-- This function uses stat internally thus if the given filepath is a symbolic link, it is
-- followed (if it points to another link the chain is followed recursively) and the information
-- is about the file it refers to. To obtain information about the link itself, see function
-- lfs.symlinkattributes.
function lfs.attributes(filepath [, aname | atable]) end

---
-- Changes the current working directory to the given path.
--
-- Returns true in case of success or nil plus an error string.
function lfs.chdir(path) end

---
-- Creates a lockfile (called lockfile.lfs) in path if it does not exist and returns the lock. If
-- the lock already exists checks if it's stale, using the second parameter (default for the
-- second parameter is INT_MAX, which in practice means the lock will never be stale. To free
-- the the lock call lock:free().
--
-- In case of any errors it returns nil and the error message. In particular, if the lock exists
-- and is not stale it returns the "File exists" message.
function lfs.lock_dir(path, [seconds_stale]) end

---
-- Returns a string with the current working directory or nil plus an error string.
function lfs.currentdir() end

---
-- Lua iterator over the entries of a given directory. Each time the iterator is called
-- with dir_obj it returns a directory entry's name as a string, or nil if there are no more
-- entries. You can also iterate by calling dir_obj:next(), and explicitly close the directory
-- before the iteration finished with dir_obj:close(). Raises an error if path is not a directory.
function lfs.dir(path) end

---
-- Locks a file or a part of it. This function works on open files; the file handle should be
-- specified as the first argument. The string mode could be either r (for a read/shared lock)
-- or w (for a write/exclusive lock). The optional arguments start and length can be used to
-- specify a starting point and its length; both should be numbers.
--
-- Returns true if the operation was successful; in case of error, it returns nil plus an
-- error string.
function lfs.lock(filehandle, mode[, start[, length]]) end

---
-- Creates a link. The first argument is the object to link to and the second is the name of the
-- link. If the optional third argument is true, the link will be a symbolic link (by default,
-- a hard link is created).
function lfs.link(old, new[, symlink]) end

---
-- Creates a new directory. The argument is the name of the new directory.
--
-- Returns true in case of success or nil, an error message and a system-dependent error code
-- in case of error.
function lfs.mkdir(dirname) end

---
-- Removes an existing directory. The argument is the name of the directory.
--
-- Returns true in case of success or nil, an error message and a system-dependent error code
-- in case of error.
function lfs.rmdir(dirname) end

---
-- Sets the writing mode for a file. The mode string can be either "binary" or "text". Returns
-- true followed by the previous mode string for the file, or nil followed by an error string
-- in case of errors. On non-Windows platforms, where the two modes are identical, setting
-- the mode has no effect, and the mode is always returned as binary.
function lfs.setmode(file, mode) end

---
-- Identical to lfs.attributes except that it obtains information about the link itself (not
-- the file it refers to). It also adds a target field, containing the file name that the
-- symlink points to. On Windows this function does not yet support links, and is identical
-- to lfs.attributes.
function lfs.symlinkattributes(filepath [, aname]) end

---
-- Set access and modification times of a file. This function is a bind to utime function. The
-- first argument is the filename, the second argument (atime) is the access time, and the
-- third argument (mtime) is the modification time. Both times are provided in seconds (which
-- should be generated with Lua standard function os.time). If the modification time is omitted,
-- the access time provided is used; if both times are omitted, the current time is used.
--
-- Returns true in case of success or nil, an error message and a system-dependent error code
-- in case of error.
function lfs.touch(filepath [, atime [, mtime]]) end

---
-- Unlocks a file or a part of it. This function works on open files; the file handle should
-- be specified as the first argument. The optional arguments start and length can be used to
-- specify a starting point and its length; both should be numbers.
--
-- Returns true if the operation was successful; in case of error, it returns nil plus an
-- error string.
function lfs.unlock(filehandle[, start[, length]]) end