---@meta

-- Return the maximum value of all items in {expr}. Example: 
-- ```vim
--     echo max([apples, pears, oranges])
-- 
-- ```
--   {expr} can be a |List| or a |Dictionary|.  For a Dictionary,
--   it returns the maximum of all values in the Dictionary.
--   If {expr} is neither a List nor a Dictionary, or one of the
--   items in {expr} cannot be used as a Number this results in
--               an error.  An empty |List| or |Dictionary| results in zero.
-- 
--   Can also be used as a |method|: 
-- ```vim
--     mylist->max()
-- ```
--- @return number
function vim.fn.max(expr) end

-- Returns a |List| of |Dictionaries| describing |menus| (defined
-- by |:menu|, |:amenu|, …), including |hidden-menus|.
-- 
-- {path} matches a menu by name, or all menus if {path} is an
-- empty string.  Example: 
-- ```vim
--   :echo menu_get('File','')
--   :echo menu_get('')
-- ```
-- {modes} is a string of zero or more modes (see |maparg()| or
-- |creating-menus| for the list of modes). "a" means "all".
-- 
-- Example: 
-- ```vim
--   nnoremenu &Test.Test inormal
--   inoremenu Test.Test insert
--   vnoremenu Test.Test x
--   echo menu_get("")
-- 
-- ```
-- returns something like this: >
-- 
--   [ {
--     "hidden": 0,
--     "name": "Test",
--     "priority": 500,
--     "shortcut": 84,
--     "submenus": [ {
--       "hidden": 0,
--       "mappings": {
--         i": {
--     "enabled": 1,
--     "noremap": 1,
--     "rhs": "insert",
--     "sid": 1,
--     "silent": 0
--         },
--         n": { ... },
--         s": { ... },
--         v": { ... }
--       },
--       "name": "Test",
--       "priority": 500,
--       "shortcut": 0
--     } ]
--   } ]
-- <
--- @param modes? any
--- @return any[]
function vim.fn.menu_get(path, modes) end

-- Return information about the specified menu {name} in
-- mode {mode}. The menu name should be specified without the
-- shortcut character ('&'). If {name} is "", then the top-level
-- menu names are returned.
-- 
-- {mode} can be one of these strings:
--   "n"  Normal
--   "v"  Visual (including Select)
--   "o"  Operator-pending
--   "i"  Insert
--   "c"  Cmd-line
--   "s"  Select
--   "x"  Visual
--   "t"  Terminal-Job
--   ""  Normal, Visual and Operator-pending
--   "!"  Insert and Cmd-line
-- When {mode} is omitted, the modes for "" are used.
-- 
-- Returns a |Dictionary| containing the following items:
--   accel    menu item accelerator text |menu-text|
--   display  display name (name without '&')
--   enabled  v:true if this menu item is enabled
--     Refer to |:menu-enable|
--   icon    name of the icon file (for toolbar)
--     |toolbar-icon|
--   iconidx  index of a built-in icon
--   modes    modes for which the menu is defined. In
--     addition to the modes mentioned above, these
--     characters will be used:
--     " "  Normal, Visual and Operator-pending
--   name    menu item name.
--   noremenu  v:true if the {rhs} of the menu item is not
--     remappable else v:false.
--   priority  menu order priority |menu-priority|
--   rhs    right-hand-side of the menu item. The returned
--     string has special characters translated like
--     in the output of the ":menu" command listing.
--     When the {rhs} of a menu item is empty, then
--     "<Nop>" is returned.
--   script  v:true if script-local remapping of {rhs} is
--     allowed else v:false.  See |:menu-script|.
--   shortcut  shortcut key (character after '&' in
--     the menu name) |menu-shortcut|
--   silent  v:true if the menu item is created
--     with <silent> argument |:menu-silent|
--   submenus  |List| containing the names of
--     all the submenus.  Present only if the menu
--     item has submenus.
-- 
-- Returns an empty dictionary if the menu item is not found.
-- 
-- Examples: 
-- ```vim
--   :echo menu_info('Edit.Cut')
--   :echo menu_info('File.Save', 'n')
-- 
--   " Display the entire menu hierarchy in a buffer
--   func ShowMenu(name, pfx)
--     let m = menu_info(a:name)
--     call append(line('$'), a:pfx .. m.display)
--     for child in m->get('submenus', [])
--       call ShowMenu(a:name .. '.' .. escape(child, '.'),
--           \ a:pfx .. '    ')
--     endfor
--   endfunc
--   new
--   for topmenu in menu_info('').submenus
--     call ShowMenu(topmenu, '')
--   endfor
-- ```
-- Can also be used as a |method|: 
-- ```vim
--   GetMenuName()->menu_info('v')
-- 
-- 
-- ```
--- @param mode? any
--- @return table<string, any>
function vim.fn.menu_info(name, mode) end

-- Return the minimum value of all items in {expr}. Example:  
-- ```vim
--     echo min([apples, pears, oranges])
-- 
-- ```
--   {expr} can be a |List| or a |Dictionary|.  For a Dictionary,
--   it returns the minimum of all values in the Dictionary.
--   If {expr} is neither a List nor a Dictionary, or one of the
--   items in {expr} cannot be used as a Number this results in
--   an error.  An empty |List| or |Dictionary| results in zero.
-- 
--   Can also be used as a |method|: 
-- ```vim
--     mylist->min()
-- 
-- ```
--- @return number
function vim.fn.min(expr) end

-- Create directory {name}.
-- 
-- When {flags} is present it must be a string.  An empty string
-- has no effect.
-- 
-- If {flags} contains "p" then intermediate directories are
-- created as necessary.
-- 
-- If {flags} contains "D" then {name} is deleted at the end of
-- the current function, as with: 
-- ```vim
--   defer delete({name}, 'd')
-- ```
-- If {flags} contains "R" then {name} is deleted recursively at
-- the end of the current function, as with: 
-- ```vim
--   defer delete({name}, 'rf')
-- ```
-- Note that when {name} has more than one part and "p" is used
-- some directories may already exist.  Only the first one that
-- is created and what it contains is scheduled to be deleted.
-- E.g. when using: 
-- ```vim
--   call mkdir('subdir/tmp/autoload', 'pR')
-- ```
-- and "subdir" already exists then "subdir/tmp" will be
-- scheduled for deletion, like with: 
-- ```vim
--   defer delete('subdir/tmp', 'rf')
-- ```
-- If {prot} is given it is used to set the protection bits of
-- the new directory.  The default is 0o755 (rwxr-xr-x: r/w for
-- the user, readable for others).  Use 0o700 to make it
-- unreadable for others.
-- 
-- {prot} is applied for all parts of {name}.  Thus if you create
-- /tmp/foo/bar then /tmp/foo will be created with 0o700. Example: 
-- ```vim
--   :call mkdir($HOME .. "/tmp/foo/bar", "p", 0o700)
-- 
-- ```
-- This function is not available in the |sandbox|.
-- 
-- If you try to create an existing directory with {flags} set to
-- "p" mkdir() will silently exit.
-- 
-- The function result is a Number, which is TRUE if the call was
-- successful or FALSE if the directory creation failed or partly
-- failed.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetName()->mkdir()
-- ```
--- @param flags? any
--- @param prot? any
--- @return number
function vim.fn.mkdir(name, flags, prot) end

-- Return a string that indicates the current mode.
--   If [expr] is supplied and it evaluates to a non-zero Number or
--   a non-empty String (|non-zero-arg|), then the full mode is
--   returned, otherwise only the first letter is returned.
-- 
--      n      Normal
--      no      Operator-pending
--      nov      Operator-pending (forced charwise |o_v|)
--      noV      Operator-pending (forced linewise |o_V|)
--      noCTRL-V Operator-pending (forced blockwise |o_CTRL-V|)
--       CTRL-V is one character
--      niI      Normal using |i_CTRL-O| in |Insert-mode|
--      niR      Normal using |i_CTRL-O| in |Replace-mode|
--      niV      Normal using |i_CTRL-O| in |Virtual-Replace-mode|
--      nt      Normal in |terminal-emulator| (insert goes to
--       Terminal mode)
--      ntT      Normal using |t_CTRL-\_CTRL-O| in |Terminal-mode|
--      v      Visual by character
--      vs      Visual by character using |v_CTRL-O| in Select mode
--      V      Visual by line
--      Vs      Visual by line using |v_CTRL-O| in Select mode
--      CTRL-V   Visual blockwise
--      CTRL-Vs  Visual blockwise using |v_CTRL-O| in Select mode
--      s      Select by character
--      S      Select by line
--      CTRL-S   Select blockwise
--      i      Insert
--      ic      Insert mode completion |compl-generic|
--      ix      Insert mode |i_CTRL-X| completion
--      R      Replace |R|
--      Rc      Replace mode completion |compl-generic|
--      Rx      Replace mode |i_CTRL-X| completion
--      Rv      Virtual Replace |gR|
--      Rvc      Virtual Replace mode completion |compl-generic|
--      Rvx      Virtual Replace mode |i_CTRL-X| completion
--      c      Command-line editing
--      cv      Vim Ex mode |gQ|
--      r      Hit-enter prompt
--      rm      The -- more -- prompt
--      r?      A |:confirm| query of some sort
--      !      Shell or external command is executing
--      t      Terminal mode: keys go to the job
-- 
--   This is useful in the 'statusline' option or RPC calls. In
--   most other places it always returns "c" or "n".
--   Note that in the future more modes and more specific modes may
--   be added. It's better not to compare the whole string but only
--   the leading character(s).
--   Also see |visualmode()|.
-- 
--   Can also be used as a |method|: 
-- ```vim
--     DoFull()->mode()
-- ```
--- @param expr? any
--- @return string
function vim.fn.mode(expr) end

-- Convert a list of VimL objects to msgpack. Returned value is a
-- |readfile()|-style list. When {type} contains "B", a |Blob| is
-- returned instead. Example: 
-- ```vim
--   call writefile(msgpackdump([{}]), 'fname.mpack', 'b')
-- ```
-- or, using a |Blob|: >
--   call writefile(msgpackdump([{}], 'B'), 'fname.mpack')
-- <
-- This will write the single 0x80 byte to a `fname.mpack` file
-- (dictionary with zero items is represented by 0x80 byte in
-- messagepack).
-- 
-- Limitations:
-- 1. |Funcref|s cannot be dumped.
-- 2. Containers that reference themselves cannot be dumped.
-- 3. Dictionary keys are always dumped as STR strings.
-- 4. Other strings and |Blob|s are always dumped as BIN strings.
-- 5. Points 3. and 4. do not apply to |msgpack-special-dict|s.
--- @param list any[]
--- @param type? any
--- @return any[]
function vim.fn.msgpackdump(list, type) end

-- Convert a |readfile()|-style list or a |Blob| to a list of
-- VimL objects.
-- Example: 
-- ```vim
--   let fname = expand('~/.config/nvim/shada/main.shada')
--   let mpack = readfile(fname, 'b')
--   let shada_objects = msgpackparse(mpack)
-- ```
-- This will read ~/.config/nvim/shada/main.shada file to
-- `shada_objects` list.
-- 
-- Limitations:
-- 1. Mapping ordering is not preserved unless messagepack
--    mapping is dumped using generic mapping
--    (|msgpack-special-map|).
-- 2. Since the parser aims to preserve all data untouched
--    (except for 1.) some strings are parsed to
--    |msgpack-special-dict| format which is not convenient to
--    use.
-- 
-- Some messagepack strings may be parsed to special
-- dictionaries. Special dictionaries are dictionaries which
-- 
-- 1. Contain exactly two keys: `_TYPE` and `_VAL`.
-- 2. `_TYPE` key is one of the types found in |v:msgpack_types|
--    variable.
-- 3. Value for `_VAL` has the following format (Key column
--    contains name of the key from |v:msgpack_types|):
-- 
-- Key  Value ~
-- nil  Zero, ignored when dumping.  Not returned by
--   |msgpackparse()| since |v:null| was introduced.
-- boolean  One or zero.  When dumping it is only checked that
--   value is a |Number|.  Not returned by |msgpackparse()|
--   since |v:true| and |v:false| were introduced.
-- integer  |List| with four numbers: sign (-1 or 1), highest two
--   bits, number with bits from 62nd to 31st, lowest 31
--   bits. I.e. to get actual number one will need to use
--   code like 
-- ```vim
--     _VAL[0] * ((_VAL[1] << 62)
--                & (_VAL[2] << 31)
--                & _VAL[3])
-- ```
--   Special dictionary with this type will appear in
--   |msgpackparse()| output under one of the following
--   circumstances:
--   1. |Number| is 32-bit and value is either above
--      INT32_MAX or below INT32_MIN.
--   2. |Number| is 64-bit and value is above INT64_MAX. It
--      cannot possibly be below INT64_MIN because msgpack
--      C parser does not support such values.
-- float  |Float|. This value cannot possibly appear in
--   |msgpackparse()| output.
-- string  |readfile()|-style list of strings. This value will
--   appear in |msgpackparse()| output if string contains
--   zero byte or if string is a mapping key and mapping is
--   being represented as special dictionary for other
--   reasons.
-- binary  |String|, or |Blob| if binary string contains zero
--   byte. This value cannot appear in |msgpackparse()|
--   output since blobs were introduced.
-- array  |List|. This value cannot appear in |msgpackparse()|
--   output.
-- 
-- map  |List| of |List|s with two items (key and value) each.
--   This value will appear in |msgpackparse()| output if
--   parsed mapping contains one of the following keys:
--   1. Any key that is not a string (including keys which
--      are binary strings).
--   2. String with NUL byte inside.
--   3. Duplicate key.
--   4. Empty key.
-- ext  |List| with two values: first is a signed integer
--   representing extension type. Second is
--   |readfile()|-style list of strings.
--- @return any[]
function vim.fn.msgpackparse(data) end

-- Return the line number of the first line at or below {lnum}
-- that is not blank.  Example: 
-- ```vim
--   if getline(nextnonblank(1)) =~ "Java"
-- ```
-- When {lnum} is invalid or there is no non-blank line at or
-- below it, zero is returned.
-- {lnum} is used like with |getline()|.
-- See also |prevnonblank()|.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetLnum()->nextnonblank()
-- ```
--- @param lnum number
--- @return number
function vim.fn.nextnonblank(lnum) end

-- Return a string with a single character, which has the number
-- value {expr}.  Examples: 
-- ```vim
--   nr2char(64)    returns "@"
--   nr2char(32)    returns " "
-- ```
-- Example for "utf-8": >
--   nr2char(300)    returns I with bow character
-- <    UTF-8 encoding is always used, {utf8} option has no effect,
-- and exists only for backwards-compatibility.
-- Note that a NUL character in the file is specified with
-- nr2char(10), because NULs are represented with newline
-- characters.  nr2char(0) is a real NUL and terminates the
-- string, thus results in an empty string.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetNumber()->nr2char()
-- ```
--- @param utf8? any
--- @return string
function vim.fn.nr2char(expr, utf8) end

-- Bitwise OR on the two arguments.  The arguments are converted
-- to a number.  A List, Dict or Float argument causes an error.
-- Also see `and()` and `xor()`.
-- Example: 
-- ```vim
--   :let bits = or(bits, 0x80)
-- ```
-- Can also be used as a |method|: >
--   :let bits = bits->or(0x80)
-- 
-- <    Rationale: The reason this is a function and not using the "|"
-- character like many languages, is that Vi has always used "|"
-- to separate commands.  In many places it would not be clear if
-- "|" is an operator or a command separator.
--- @return number
vim.fn["or"] = function(expr, expr1) end

-- Shorten directory names in the path {path} and return the
-- result.  The tail, the file name, is kept as-is.  The other
-- components in the path are reduced to {len} letters in length.
-- If {len} is omitted or smaller than 1 then 1 is used (single
-- letters).  Leading '~' and '.' characters are kept.  Examples: 
-- ```vim
--   :echo pathshorten('~/.config/nvim/autoload/file1.vim')
-- ```
--   ~/.c/n/a/file1.vim ~
-- ```vim
--   :echo pathshorten('~/.config/nvim/autoload/file2.vim', 2)
-- ```
--   ~/.co/nv/au/file2.vim ~
-- It doesn't matter if the path exists or not.
-- Returns an empty string on error.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetDirectories()->pathshorten()
-- ```
--- @param len? any
--- @return string
function vim.fn.pathshorten(path, len) end

-- Evaluate |perl| expression {expr} and return its result
-- converted to Vim data structures.
-- Numbers and strings are returned as they are (strings are
-- copied though).
-- Lists are represented as Vim |List| type.
-- Dictionaries are represented as Vim |Dictionary| type,
-- non-string keys result in error.
-- 
-- Note: If you want an array or hash, {expr} must return a
-- reference to it.
-- Example: 
-- ```vim
--   :echo perleval('[1 .. 4]')
-- ```
--   [1, 2, 3, 4]
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetExpr()->perleval()
-- ```
function vim.fn.perleval(expr) end

-- Return the power of {x} to the exponent {y} as a |Float|.
-- {x} and {y} must evaluate to a |Float| or a |Number|.
-- Returns 0.0 if {x} or {y} is not a |Float| or a |Number|.
-- Examples: 
-- ```vim
--   :echo pow(3, 3)
-- ```
--   27.0 >
--   :echo pow(2, 16)
-- <      65536.0 
-- ```vim
--   :echo pow(32, 0.20)
-- ```
--   2.0
-- 
-- Can also be used as a |method|: 
-- ```vim
--   Compute()->pow(3)
-- ```
--- @return float
function vim.fn.pow(x, y) end

-- Return the line number of the first line at or above {lnum}
-- that is not blank.  Example: 
-- ```vim
--   let ind = indent(prevnonblank(v:lnum - 1))
-- ```
-- When {lnum} is invalid or there is no non-blank line at or
-- above it, zero is returned.
-- {lnum} is used like with |getline()|.
-- Also see |nextnonblank()|.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetLnum()->prevnonblank()
-- ```
--- @param lnum number
--- @return number
function vim.fn.prevnonblank(lnum) end

-- Return a String with {fmt}, where "%" items are replaced by
-- the formatted form of their respective arguments.  Example: 
-- ```vim
--   printf("%4d: E%d %.30s", lnum, errno, msg)
-- ```
-- May result in:
--   "  99: E42 asdfasdfasdfasdfasdfasdfasdfas" ~
-- 
-- When used as a |method| the base is passed as the second
-- argument: 
-- ```vim
--   Compute()->printf("result: %d")
-- ```
-- You can use `call()` to pass the items as a list.
-- 
-- Often used items are:
--   %s  string
--   %6S  string right-aligned in 6 display cells
--   %6s  string right-aligned in 6 bytes
--   %.9s  string truncated to 9 bytes
--   %c  single byte
--   %d  decimal number
--   %5d  decimal number padded with spaces to 5 characters
--   %b  binary number
--   %08b  binary number padded with zeros to at least 8 characters
--   %B  binary number using upper case letters
--   %x  hex number
--   %04x  hex number padded with zeros to at least 4 characters
--   %X  hex number using upper case letters
--   %o  octal number
--   %f  floating point number as 12.23, inf, -inf or nan
--   %F  floating point number as 12.23, INF, -INF or NAN
--   %e  floating point number as 1.23e3, inf, -inf or nan
--   %E  floating point number as 1.23E3, INF, -INF or NAN
--   %g  floating point number, as %f or %e depending on value
--   %G  floating point number, as %F or %E depending on value
--   %%  the % character itself
--   %p  representation of the pointer to the container
-- 
-- Conversion specifications start with '%' and end with the
-- conversion type.  All other characters are copied unchanged to
-- the result.
-- 
-- The "%" starts a conversion specification.  The following
-- arguments appear in sequence:
-- 
--   %  [flags]  [field-width]  [.precision]  type
-- 
-- flags
--   Zero or more of the following flags:
-- 
--     #        The value should be converted to an "alternate
--         form".  For c, d, and s conversions, this option
--         has no effect.  For o conversions, the precision
--         of the number is increased to force the first
--         character of the output string to a zero (except
--         if a zero value is printed with an explicit
--         precision of zero).
--         For x and X conversions, a non-zero result has
--         the string "0x" (or "0X" for X conversions)
--         prepended to it.
-- 
--     0 (zero)  Zero padding.  For all conversions the converted
--         value is padded on the left with zeros rather
--         than blanks.  If a precision is given with a
--         numeric conversion (d, o, x, and X), the 0 flag
--         is ignored.
-- 
--     -        A negative field width flag; the converted value
--         is to be left adjusted on the field boundary.
--         The converted value is padded on the right with
--         blanks, rather than on the left with blanks or
--         zeros.  A - overrides a 0 if both are given.
-- 
--     ' ' (space)  A blank should be left before a positive
--         number produced by a signed conversion (d).
-- 
--     +        A sign must always be placed before a number
--         produced by a signed conversion.  A + overrides
--         a space if both are used.
-- 
-- field-width
--   An optional decimal digit string specifying a minimum
--   field width.  If the converted value has fewer bytes
--   than the field width, it will be padded with spaces on
--   the left (or right, if the left-adjustment flag has
--   been given) to fill out the field width.  For the S
--   conversion the count is in cells.
-- 
-- .precision
--   An optional precision, in the form of a period '.'
--   followed by an optional digit string.  If the digit
--   string is omitted, the precision is taken as zero.
--   This gives the minimum number of digits to appear for
--   d, o, x, and X conversions, the maximum number of
--   bytes to be printed from a string for s conversions,
--   or the maximum number of cells to be printed from a
--   string for S conversions.
--   For floating point it is the number of digits after
--   the decimal point.
-- 
-- type
--   A character that specifies the type of conversion to
--   be applied, see below.
-- 
-- A field width or precision, or both, may be indicated by an
-- asterisk "*" instead of a digit string.  In this case, a
-- Number argument supplies the field width or precision.  A
-- negative field width is treated as a left adjustment flag
-- followed by a positive field width; a negative precision is
-- treated as though it were missing.  Example: 
-- ```vim
--   :echo printf("%d: %.*s", nr, width, line)
-- ```
-- This limits the length of the text used from "line" to
-- "width" bytes.
-- 
-- The conversion specifiers and their meanings are:
-- 
-- 
-- dbBoxX  The Number argument is converted to signed decimal (d),
--   unsigned binary (b and B), unsigned octal (o), or
--   unsigned hexadecimal (x and X) notation.  The letters
--   "abcdef" are used for x conversions; the letters
--   "ABCDEF" are used for X conversions.  The precision, if
--   any, gives the minimum number of digits that must
--   appear; if the converted value requires fewer digits, it
--   is padded on the left with zeros.  In no case does a
--   non-existent or small field width cause truncation of a
--   numeric field; if the result of a conversion is wider
--   than the field width, the field is expanded to contain
--   the conversion result.
--   The 'h' modifier indicates the argument is 16 bits.
--   The 'l' modifier indicates the argument is 32 bits.
--   The 'L' modifier indicates the argument is 64 bits.
--   Generally, these modifiers are not useful. They are
--   ignored when type is known from the argument.
-- 
-- i  alias for d
-- D  alias for ld
-- U  alias for lu
-- O  alias for lo
-- 
-- 
-- c  The Number argument is converted to a byte, and the
--   resulting character is written.
-- 
-- 
-- s  The text of the String argument is used.  If a
--   precision is specified, no more bytes than the number
--   specified are used.
--   If the argument is not a String type, it is
--   automatically converted to text with the same format
--   as ":echo".
-- 
-- S  The text of the String argument is used.  If a
--   precision is specified, no more display cells than the
--   number specified are used.
-- 
-- 
-- f F  The Float argument is converted into a string of the
--   form 123.456.  The precision specifies the number of
--   digits after the decimal point.  When the precision is
--   zero the decimal point is omitted.  When the precision
--   is not specified 6 is used.  A really big number
--   (out of range or dividing by zero) results in "inf"
--    or "-inf" with %f (INF or -INF with %F).
--    "0.0 / 0.0" results in "nan" with %f (NAN with %F).
--   Example: 
-- ```vim
--     echo printf("%.2f", 12.115)
-- ```
--     12.12
--   Note that roundoff depends on the system libraries.
--   Use |round()| when in doubt.
-- 
-- 
-- e E  The Float argument is converted into a string of the
--   form 1.234e+03 or 1.234E+03 when using 'E'.  The
--   precision specifies the number of digits after the
--   decimal point, like with 'f'.
-- 
-- 
-- g G  The Float argument is converted like with 'f' if the
--   value is between 0.001 (inclusive) and 10000000.0
--   (exclusive).  Otherwise 'e' is used for 'g' and 'E'
--   for 'G'.  When no precision is specified superfluous
--   zeroes and '+' signs are removed, except for the zero
--   immediately after the decimal point.  Thus 10000000.0
--   results in 1.0e7.
-- 
-- 
-- %  A '%' is written.  No argument is converted.  The
--   complete conversion specification is "%%".
-- 
-- When a Number argument is expected a String argument is also
-- accepted and automatically converted.
-- When a Float or String argument is expected a Number argument
-- is also accepted and automatically converted.
-- Any other argument type results in an error message.
-- 
-- 
-- The number of {exprN} arguments must exactly match the number
-- of "%" items.  If there are not sufficient or too many
-- arguments an error is given.  Up to 18 arguments can be used.
--- @return string
function vim.fn.printf(fmt, expr1, ...) end

-- Returns the effective prompt text for buffer {buf}.  {buf} can
-- be a buffer name or number.  See |prompt-buffer|.
-- 
-- If the buffer doesn't exist or isn't a prompt buffer, an empty
-- string is returned.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetBuffer()->prompt_getprompt()
-- ```
--- @param buf buffer
--- @return string
function vim.fn.prompt_getprompt(buf) end

-- Set prompt callback for buffer {buf} to {expr}.  When {expr}
-- is an empty string the callback is removed.  This has only
-- effect if {buf} has 'buftype' set to "prompt".
-- 
-- The callback is invoked when pressing Enter.  The current
-- buffer will always be the prompt buffer.  A new line for a
-- prompt is added before invoking the callback, thus the prompt
-- for which the callback was invoked will be in the last but one
-- line.
-- If the callback wants to add text to the buffer, it must
-- insert it above the last line, since that is where the current
-- prompt is.  This can also be done asynchronously.
-- The callback is invoked with one argument, which is the text
-- that was entered at the prompt.  This can be an empty string
-- if the user only typed Enter.
-- Example: 
-- ```vim
--    func s:TextEntered(text)
--      if a:text == 'exit' || a:text == 'quit'
--        stopinsert
--        " Reset 'modified' to allow the buffer to be closed.
--        " We assume there is nothing useful to be saved.
--        set nomodified
--        close
--      else
--        " Do something useful with "a:text".  In this example
--        " we just repeat it.
--        call append(line('$') - 1, 'Entered: "' .. a:text .. '"')
--      endif
--    endfunc
--    call prompt_setcallback(bufnr(), function('s:TextEntered'))
-- 
-- ```
-- Can also be used as a |method|: >
--   GetBuffer()->prompt_setcallback(callback)
--- @param buf buffer
function vim.fn.prompt_setcallback(buf, expr) end

-- Set a callback for buffer {buf} to {expr}.  When {expr} is an
-- empty string the callback is removed.  This has only effect if
-- {buf} has 'buftype' set to "prompt".
-- 
-- This callback will be invoked when pressing CTRL-C in Insert
-- mode.  Without setting a callback Vim will exit Insert mode,
-- as in any buffer.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetBuffer()->prompt_setinterrupt(callback)
-- ```
--- @param buf buffer
function vim.fn.prompt_setinterrupt(buf, expr) end

-- Set prompt for buffer {buf} to {text}.  You most likely want
-- {text} to end in a space.
-- The result is only visible if {buf} has 'buftype' set to
-- "prompt".  Example: 
-- ```vim
--   call prompt_setprompt(bufnr(''), 'command: ')
-- ```
-- Can also be used as a |method|: 
-- ```vim
--   GetBuffer()->prompt_setprompt('command: ')
-- ```
--- @param buf buffer
--- @param text string
function vim.fn.prompt_setprompt(buf, text) end

-- If the popup menu (see |ins-completion-menu|) is not visible,
-- returns an empty |Dictionary|, otherwise, returns a
-- |Dictionary| with the following keys:
--   height    nr of items visible
--   width    screen cells
--   row    top screen row (0 first row)
--   col    leftmost screen column (0 first col)
--   size    total nr of items
--   scrollbar  |TRUE| if scrollbar is visible
-- 
-- The values are the same as in |v:event| during |CompleteChanged|.
--- @return table<string, any>
function vim.fn.pum_getpos() end

-- Returns non-zero when the popup menu is visible, zero
-- otherwise.  See |ins-completion-menu|.
-- This can be used to avoid some things that would remove the
-- popup menu.
--- @return number
function vim.fn.pumvisible() end

-- Evaluate Python expression {expr} and return its result
-- converted to Vim data structures.
-- Numbers and strings are returned as they are (strings are
-- copied though, Unicode strings are additionally converted to
-- UTF-8).
-- Lists are represented as Vim |List| type.
-- Dictionaries are represented as Vim |Dictionary| type with
-- keys converted to strings.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetExpr()->py3eval()
-- ```
function vim.fn.py3eval(expr) end

-- Evaluate Python expression {expr} and return its result
-- converted to Vim data structures.
-- Numbers and strings are returned as they are (strings are
-- copied though).
-- Lists are represented as Vim |List| type.
-- Dictionaries are represented as Vim |Dictionary| type,
-- non-string keys result in error.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetExpr()->pyeval()
-- ```
function vim.fn.pyeval(expr) end

-- Evaluate Python expression {expr} and return its result
-- converted to Vim data structures.
-- Uses Python 2 or 3, see |python_x| and 'pyxversion'.
-- See also: |pyeval()|, |py3eval()|
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetExpr()->pyxeval()
-- ```
function vim.fn.pyxeval(expr) end

-- Return a pseudo-random Number generated with an xoshiro128
-- algorithm using seed {expr}.  The returned number is 32 bits,
-- also on 64 bits systems, for consistency.
-- {expr} can be initialized by |srand()| and will be updated by
-- rand().  If {expr} is omitted, an internal seed value is used
-- and updated.
-- Returns -1 if {expr} is invalid.
-- 
-- Examples: 
-- ```vim
--   :echo rand()
--   :let seed = srand()
--   :echo rand(seed)
--   :echo rand(seed) % 16  " random number 0 - 15
-- ```
-- Can also be used as a |method|: 
-- ```vim
--   seed->rand()
-- ```
--- @param expr? any
--- @return number
function vim.fn.rand(expr) end

-- Returns a |List| with Numbers:
-- - If only {expr} is specified: [0, 1, ..., {expr} - 1]
-- - If {max} is specified: [{expr}, {expr} + 1, ..., {max}]
-- - If {stride} is specified: [{expr}, {expr} + {stride}, ...,
--   {max}] (increasing {expr} with {stride} each time, not
--   producing a value past {max}).
-- When the maximum is one before the start the result is an
-- empty list.  When the maximum is more than one before the
-- start this is an error.
-- Examples: 
-- ```vim
--   range(4)    " [0, 1, 2, 3]
--   range(2, 4)    " [2, 3, 4]
--   range(2, 9, 3)    " [2, 5, 8]
--   range(2, -2, -1)  " [2, 1, 0, -1, -2]
--   range(0)    " []
--   range(2, 0)    " error!
-- ```
-- Can also be used as a |method|: 
-- ```vim
--   GetExpr()->range()
-- ```
--- @param max? any
--- @param stride? any
--- @return any[]
function vim.fn.range(expr, max, stride) end

-- Read file {fname} in binary mode and return a |Blob|.
-- If {offset} is specified, read the file from the specified
-- offset.  If it is a negative value, it is used as an offset
-- from the end of the file.  E.g., to read the last 12 bytes: 
-- ```vim
--   readblob('file.bin', -12)
-- ```
-- If {size} is specified, only the specified size will be read.
-- E.g. to read the first 100 bytes of a file: 
-- ```vim
--   readblob('file.bin', 0, 100)
-- ```
-- If {size} is -1 or omitted, the whole data starting from
-- {offset} will be read.
-- This can be also used to read the data from a character device
-- on Unix when {size} is explicitly set.  Only if the device
-- supports seeking {offset} can be used.  Otherwise it should be
-- zero.  E.g. to read 10 bytes from a serial console: 
-- ```vim
--   readblob('/dev/ttyS0', 0, 10)
-- ```
-- When the file can't be opened an error message is given and
-- the result is an empty |Blob|.
-- When the offset is beyond the end of the file the result is an
-- empty blob.
-- When trying to read more bytes than are available the result
-- is truncated.
-- Also see |readfile()| and |writefile()|.
--- @param offset? any
--- @param size? any
function vim.fn.readblob(fname, offset, size) end

-- Return a list with file and directory names in {directory}.
-- You can also use |glob()| if you don't need to do complicated
-- things, such as limiting the number of matches.
-- 
-- When {expr} is omitted all entries are included.
-- When {expr} is given, it is evaluated to check what to do:
--   If {expr} results in -1 then no further entries will
--   be handled.
--   If {expr} results in 0 then this entry will not be
--   added to the list.
--   If {expr} results in 1 then this entry will be added
--   to the list.
-- Each time {expr} is evaluated |v:val| is set to the entry name.
-- When {expr} is a function the name is passed as the argument.
-- For example, to get a list of files ending in ".txt": 
-- ```vim
--   readdir(dirname, {n -> n =~ '.txt$'})
-- ```
-- To skip hidden and backup files: >
--   readdir(dirname, {n -> n !~ '^\.\|\~$'})
-- 
-- <    If you want to get a directory tree: 
-- ```vim
--               function! s:tree(dir)
--                   return {a:dir : map(readdir(a:dir),
--       \ {_, x -> isdirectory(x) ?
--       \          {x : s:tree(a:dir .. '/' .. x)} : x})}
--               endfunction
--               echo s:tree(".")
-- ```
-- Returns an empty List on error.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetDirName()->readdir()
-- ```
--- @param expr? any
--- @return any[]
function vim.fn.readdir(directory, expr) end

-- Read file {fname} and return a |List|, each line of the file
-- as an item.  Lines are broken at NL characters.  Macintosh
-- files separated with CR will result in a single long line
-- (unless a NL appears somewhere).
-- All NUL characters are replaced with a NL character.
-- When {type} contains "b" binary mode is used:
-- - When the last line ends in a NL an extra empty list item is
--   added.
-- - No CR characters are removed.
-- Otherwise:
-- - CR characters that appear before a NL are removed.
-- - Whether the last line ends in a NL or not does not matter.
-- - Any UTF-8 byte order mark is removed from the text.
-- When {max} is given this specifies the maximum number of lines
-- to be read.  Useful if you only want to check the first ten
-- lines of a file: 
-- ```vim
--   :for line in readfile(fname, '', 10)
--   :  if line =~ 'Date' | echo line | endif
--   :endfor
-- ```
-- When {max} is negative -{max} lines from the end of the file
-- are returned, or as many as there are.
-- When {max} is zero the result is an empty list.
-- Note that without {max} the whole file is read into memory.
-- Also note that there is no recognition of encoding.  Read a
-- file into a buffer if you need to.
-- Deprecated (use |readblob()| instead): When {type} contains
-- "B" a |Blob| is returned with the binary data of the file
-- unmodified.
-- When the file can't be opened an error message is given and
-- the result is an empty list.
-- Also see |writefile()|.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetFileName()->readfile()
-- ```
--- @param type? any
--- @param max? any
--- @return any[]
function vim.fn.readfile(fname, type, max) end

-- {func} is called for every item in {object}, which can be a
-- |List| or a |Blob|.  {func} is called with two arguments: the
-- result so far and current item.  After processing all items
-- the result is returned.
-- 
-- {initial} is the initial result.  When omitted, the first item
-- in {object} is used and {func} is first called for the second
-- item.  If {initial} is not given and {object} is empty no
-- result can be computed, an E998 error is given.
-- 
-- Examples: 
-- ```vim
--   echo reduce([1, 3, 5], { acc, val -> acc + val })
--   echo reduce(['x', 'y'], { acc, val -> acc .. val }, 'a')
--   echo reduce(0z1122, { acc, val -> 2 * acc + val })
-- ```
-- Can also be used as a |method|: 
-- ```vim
--   echo mylist->reduce({ acc, val -> acc + val }, 0)
-- ```
--- @param func fun()
--- @param initial? any
function vim.fn.reduce(object, func, initial) end

-- Returns the single letter name of the register being executed.
-- Returns an empty string when no register is being executed.
-- See |@|.
--- @return string
function vim.fn.reg_executing() end

-- Returns the single letter name of the last recorded register.
-- Returns an empty string when nothing was recorded yet.
-- See |q| and |Q|.
--- @return string
function vim.fn.reg_recorded() end

-- Returns the single letter name of the register being recorded.
-- Returns an empty string when not recording.  See |q|.
--- @return string
function vim.fn.reg_recording() end

-- Return an item that represents a time value.  The item is a
-- list with items that depend on the system.
-- The item can be passed to |reltimestr()| to convert it to a
-- string or |reltimefloat()| to convert to a Float.
-- 
-- Without an argument it returns the current "relative time", an
-- implementation-defined value meaningful only when used as an
-- argument to |reltime()|, |reltimestr()| and |reltimefloat()|.
-- 
-- With one argument it returns the time passed since the time
-- specified in the argument.
-- With two arguments it returns the time passed between {start}
-- and {end}.
-- 
-- The {start} and {end} arguments must be values returned by
-- reltime().  Returns zero on error.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetStart()->reltime()
-- ```
-- Note: |localtime()| returns the current (non-relative) time.
--- @param start number
--- @param end_ number
--- @return any[]
function vim.fn.reltime(start, end_) end

-- Return a Float that represents the time value of {time}.
-- Unit of time is seconds.
-- Example:
--   let start = reltime()
--   call MyFunction()
--   let seconds = reltimefloat(reltime(start))
-- See the note of reltimestr() about overhead.
-- Also see |profiling|.
-- If there is an error an empty string is returned
-- 
-- Can also be used as a |method|: 
-- ```vim
--   reltime(start)->reltimefloat()
-- ```
--- @return float
function vim.fn.reltimefloat(time) end

-- Return a String that represents the time value of {time}.
-- This is the number of seconds, a dot and the number of
-- microseconds.  Example: 
-- ```vim
--   let start = reltime()
--   call MyFunction()
--   echo reltimestr(reltime(start))
-- ```
-- Note that overhead for the commands will be added to the time.
-- Leading spaces are used to make the string align nicely.  You
-- can use split() to remove it. 
-- ```vim
--   echo split(reltimestr(reltime(start)))[0]
-- ```
-- Also see |profiling|.
-- If there is an error an empty string is returned
-- 
-- Can also be used as a |method|: 
-- ```vim
--   reltime(start)->reltimestr()
-- ```
--- @return string
function vim.fn.reltimestr(time) end

-- Remove the entry from {dict} with key {key} and return it.
-- Example: 
-- ```vim
--   :echo "removed " .. remove(dict, "one")
-- ```
-- If there is no {key} in {dict} this is an error.
-- Returns zero on error.
--- @param dict table<string, any>
function vim.fn.remove(dict, key) end

-- Rename the file by the name {from} to the name {to}.  This
-- should also work to move files across file systems.  The
-- result is a Number, which is 0 if the file was renamed
-- successfully, and non-zero when the renaming failed.
-- NOTE: If {to} exists it is overwritten without warning.
-- This function is not available in the |sandbox|.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetOldName()->rename(newname)
-- ```
--- @param from number
--- @param to number
--- @return number
function vim.fn.rename(from, to) end

-- Repeat {expr} {count} times and return the concatenated
-- result.  Example: 
-- ```vim
--   :let separator = repeat('-', 80)
-- ```
-- When {count} is zero or negative the result is empty.
-- When {expr} is a |List| or a |Blob| the result is {expr}
-- concatenated {count} times.  Example: 
-- ```vim
--   :let longlist = repeat(['a', 'b'], 3)
-- ```
-- Results in ['a', 'b', 'a', 'b', 'a', 'b'].
-- 
-- Can also be used as a |method|: 
-- ```vim
--   mylist->repeat(count)
-- ```
--- @return any[]
vim.fn["repeat"] = function(expr, count) end

-- On MS-Windows, when {filename} is a shortcut (a .lnk file),
-- returns the path the shortcut points to in a simplified form.
-- On Unix, repeat resolving symbolic links in all path
-- components of {filename} and return the simplified result.
-- To cope with link cycles, resolving of symbolic links is
-- stopped after 100 iterations.
-- On other systems, return the simplified {filename}.
-- The simplification step is done as by |simplify()|.
-- resolve() keeps a leading path component specifying the
-- current directory (provided the result is still a relative
-- path name) and also keeps a trailing path separator.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetName()->resolve()
-- ```
--- @return string
function vim.fn.resolve(filename) end

-- Reverse the order of items in {object} in-place.
-- {object} can be a |List| or a |Blob|.
-- Returns {object}.
-- Returns zero if {object} is not a List or a Blob.
-- If you want an object to remain unmodified make a copy first: 
-- ```vim
--   :let revlist = reverse(copy(mylist))
-- ```
-- Can also be used as a |method|: >
--   mylist->reverse()
--- @return any[]
function vim.fn.reverse(object) end

-- Round off {expr} to the nearest integral value and return it
-- as a |Float|.  If {expr} lies halfway between two integral
-- values, then use the larger one (away from zero).
-- {expr} must evaluate to a |Float| or a |Number|.
-- Returns 0.0 if {expr} is not a |Float| or a |Number|.
-- Examples: 
-- ```vim
--   echo round(0.456)
-- ```
--   0.0  >
--   echo round(4.5)
-- <      5.0 
-- ```vim
--   echo round(-4.5)
-- ```
--   -5.0
-- 
-- Can also be used as a |method|: 
-- ```vim
--   Compute()->round()
-- ```
--- @return float
function vim.fn.round(expr) end

-- Sends {event} to {channel} via |RPC| and returns immediately.
-- If {channel} is 0, the event is broadcast to all channels.
-- Example: 
-- ```vim
--   :au VimLeave call rpcnotify(0, "leaving")
-- ```
--- @param args? any[]
--- @param ...? any
function vim.fn.rpcnotify(channel, event, args, ...) end

-- Sends a request to {channel} to invoke {method} via
-- |RPC| and blocks until a response is received.
-- Example: 
-- ```vim
--   :let result = rpcrequest(rpc_chan, "func", 1, 2, 3)
-- ```
--- @param args? any
--- @param ...? any
--- @return any
function vim.fn.rpcrequest(channel, method, args, ...) end

-- Deprecated. Replace  
-- ```vim
--   :let id = rpcstart('prog', ['arg1', 'arg2'])
-- ```
-- with >
--   :let id = jobstart(['prog', 'arg1', 'arg2'], {'rpc': v:true})
--- @param argv? any
function vim.fn.rpcstart(prog, argv) end

-- Evaluate Ruby expression {expr} and return its result
-- converted to Vim data structures.
-- Numbers, floats and strings are returned as they are (strings
-- are copied though).
-- Arrays are represented as Vim |List| type.
-- Hashes are represented as Vim |Dictionary| type.
-- Other objects are represented as strings resulted from their
-- "Object#to_s" method.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetRubyExpr()->rubyeval()
-- ```
function vim.fn.rubyeval(expr) end

-- Like |screenchar()|, but return the attribute.  This is a rather
-- arbitrary number that can only be used to compare to the
-- attribute at other positions.
-- Returns -1 when row or col is out of range.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetRow()->screenattr(col)
-- ```
--- @param col number
--- @return number
function vim.fn.screenattr(row, col) end

-- The result is a Number, which is the character at position
-- [row, col] on the screen.  This works for every possible
-- screen position, also status lines, window separators and the
-- command line.  The top left position is row one, column one
-- The character excludes composing characters.  For double-byte
-- encodings it may only be the first byte.
-- This is mainly to be used for testing.
-- Returns -1 when row or col is out of range.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetRow()->screenchar(col)
-- ```
--- @param col number
--- @return number
function vim.fn.screenchar(row, col) end

-- The result is a List of Numbers.  The first number is the same
-- as what |screenchar()| returns.  Further numbers are
-- composing characters on top of the base character.
-- This is mainly to be used for testing.
-- Returns an empty List when row or col is out of range.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetRow()->screenchars(col)
-- ```
--- @param col number
--- @return any[]
function vim.fn.screenchars(row, col) end

-- The result is a Number, which is the current screen column of
-- the cursor. The leftmost column has number 1.
-- This function is mainly used for testing.
-- 
-- Note: Always returns the current screen column, thus if used
-- in a command (e.g. ":echo screencol()") it will return the
-- column inside the command line, which is 1 when the command is
-- executed. To get the cursor position in the file use one of
-- the following mappings: 
-- ```vim
--   nnoremap <expr> GG ":echom " .. screencol() .. "\n"
--   nnoremap <silent> GG :echom screencol()<CR>
--   noremap GG <Cmd>echom screencol()<Cr>
-- ```
--- @return number
function vim.fn.screencol() end

-- The result is a Dict with the screen position of the text
-- character in window {winid} at buffer line {lnum} and column
-- {col}.  {col} is a one-based byte index.
-- The Dict has these members:
--   row  screen row
--   col  first screen column
--   endcol  last screen column
--   curscol  cursor screen column
-- If the specified position is not visible, all values are zero.
-- The "endcol" value differs from "col" when the character
-- occupies more than one screen cell.  E.g. for a Tab "col" can
-- be 1 and "endcol" can be 8.
-- The "curscol" value is where the cursor would be placed.  For
-- a Tab it would be the same as "endcol", while for a double
-- width character it would be the same as "col".
-- The |conceal| feature is ignored here, the column numbers are
-- as if 'conceallevel' is zero.  You can set the cursor to the
-- right position and use |screencol()| to get the value with
-- |conceal| taken into account.
-- If the position is in a closed fold the screen position of the
-- first character is returned, {col} is not used.
-- Returns an empty Dict if {winid} is invalid.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetWinid()->screenpos(lnum, col)
-- ```
--- @param winid window
--- @param lnum number
--- @param col number
--- @return table<string, any>
function vim.fn.screenpos(winid, lnum, col) end

-- The result is a Number, which is the current screen row of the
-- cursor.  The top line has number one.
-- This function is mainly used for testing.
-- Alternatively you can use |winline()|.
-- 
-- Note: Same restrictions as with |screencol()|.
--- @return number
function vim.fn.screenrow() end

-- The result is a String that contains the base character and
-- any composing characters at position [row, col] on the screen.
-- This is like |screenchars()| but returning a String with the
-- characters.
-- This is mainly to be used for testing.
-- Returns an empty String when row or col is out of range.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetRow()->screenstring(col)
-- ```
--- @param col number
--- @return string
function vim.fn.screenstring(row, col) end

-- Search for regexp pattern {pattern}.  The search starts at the
-- cursor position (you can use |cursor()| to set it).
-- 
-- When a match has been found its line number is returned.
-- If there is no match a 0 is returned and the cursor doesn't
-- move.  No error message is given.
-- 
-- {flags} is a String, which can contain these character flags:
-- 'b'  search Backward instead of forward
-- 'c'  accept a match at the Cursor position
-- 'e'  move to the End of the match
-- 'n'  do Not move the cursor
-- 'p'  return number of matching sub-Pattern (see below)
-- 's'  Set the ' mark at the previous location of the cursor
-- 'w'  Wrap around the end of the file
-- 'W'  don't Wrap around the end of the file
-- 'z'  start searching at the cursor column instead of Zero
-- If neither 'w' or 'W' is given, the 'wrapscan' option applies.
-- 
-- If the 's' flag is supplied, the ' mark is set, only if the
-- cursor is moved. The 's' flag cannot be combined with the 'n'
-- flag.
-- 
-- 'ignorecase', 'smartcase' and 'magic' are used.
-- 
-- When the 'z' flag is not given, forward searching always
-- starts in column zero and then matches before the cursor are
-- skipped.  When the 'c' flag is present in 'cpo' the next
-- search starts after the match.  Without the 'c' flag the next
-- search starts one column after the start of the match.  This
-- matters for overlapping matches.  See |cpo-c|.  You can also
-- insert "\ze" to change where the match ends, see  |/\ze|.
-- 
-- When searching backwards and the 'z' flag is given then the
-- search starts in column zero, thus no match in the current
-- line will be found (unless wrapping around the end of the
-- file).
-- 
-- When the {stopline} argument is given then the search stops
-- after searching this line.  This is useful to restrict the
-- search to a range of lines.  Examples: 
-- ```vim
--   let match = search('(', 'b', line("w0"))
--   let end = search('END', '', line("w$"))
-- ```
-- When {stopline} is used and it is not zero this also implies
-- that the search does not wrap around the end of the file.
-- A zero value is equal to not giving the argument.
-- 
-- When the {timeout} argument is given the search stops when
-- more than this many milliseconds have passed.  Thus when
-- {timeout} is 500 the search stops after half a second.
-- The value must not be negative.  A zero value is like not
-- giving the argument.
-- 
-- If the {skip} expression is given it is evaluated with the
-- cursor positioned on the start of a match.  If it evaluates to
-- non-zero this match is skipped.  This can be used, for
-- example, to skip a match in a comment or a string.
-- {skip} can be a string, which is evaluated as an expression, a
-- function reference or a lambda.
-- When {skip} is omitted or empty, every match is accepted.
-- When evaluating {skip} causes an error the search is aborted
-- and -1 returned.
-- 
-- With the 'p' flag the returned value is one more than the
-- first sub-match in \(\).  One if none of them matched but the
-- whole pattern did match.
-- To get the column number too use |searchpos()|.
-- 
-- The cursor will be positioned at the match, unless the 'n'
-- flag is used.
-- 
-- Example (goes over all files in the argument list): 
-- ```vim
--     :let n = 1
--     :while n <= argc()      " loop over all files in arglist
--     :  exe "argument " .. n
--     :  " start at the last char in the file and wrap for the
--     :  " first search to find match at start of file
--     :  normal G$
--     :  let flags = "w"
--     :  while search("foo", flags) > 0
--     :   s/foo/bar/g
--     :   let flags = "W"
--     :  endwhile
--     :  update        " write the file if modified
--     :  let n = n + 1
--     :endwhile
-- ```
-- Example for using some flags: 
-- ```vim
--     :echo search('\<if\|\(else\)\|\(endif\)', 'ncpe')
-- ```
-- This will search for the keywords "if", "else", and "endif"
-- under or after the cursor.  Because of the 'p' flag, it
-- returns 1, 2, or 3 depending on which keyword is found, or 0
-- if the search fails.  With the cursor on the first word of the
-- line:
--     if (foo == 0) | let foo = foo + 1 | endif ~
-- the function returns 1.  Without the 'c' flag, the function
-- finds the "endif" and returns 3.  The same thing happens
-- without the 'e' flag if the cursor is on the "f" of "if".
-- The 'n' flag tells the function not to move the cursor.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetPattern()->search()
-- ```
--- @param flags? any
--- @param stopline? any
--- @param timeout? any
--- @param skip? any
--- @return number
function vim.fn.search(pattern, flags, stopline, timeout, skip) end

-- Get or update the last search count, like what is displayed
-- without the "S" flag in 'shortmess'.  This works even if
-- 'shortmess' does contain the "S" flag.
-- 
-- This returns a Dictionary. The dictionary is empty if the
-- previous pattern was not set and "pattern" was not specified.
-- 
--   key    type    meaning ~
--   current  |Number|  current position of match;
--         0 if the cursor position is
--         before the first match
--   exact_match  |Boolean|  1 if "current" is matched on
--         "pos", otherwise 0
--   total    |Number|  total count of matches found
--   incomplete  |Number|  0: search was fully completed
--         1: recomputing was timed out
--         2: max count exceeded
-- 
-- For {options} see further down.
-- 
-- To get the last search count when |n| or |N| was pressed, call
-- this function with `recompute: 0` . This sometimes returns
-- wrong information because |n| and |N|'s maximum count is 99.
-- If it exceeded 99 the result must be max count + 1 (100). If
-- you want to get correct information, specify `recompute: 1`: 
-- ```vim
-- 
--   " result == maxcount + 1 (100) when many matches
--   let result = searchcount(#{recompute: 0})
-- 
--   " Below returns correct result (recompute defaults
--   " to 1)
--   let result = searchcount()
-- ```
-- The function is useful to add the count to 'statusline': 
-- ```vim
--   function! LastSearchCount() abort
--     let result = searchcount(#{recompute: 0})
--     if empty(result)
--       return ''
--     endif
--     if result.incomplete ==# 1     " timed out
--       return printf(' /%s [?/??]', @/)
--     elseif result.incomplete ==# 2 " max count exceeded
--       if result.total > result.maxcount &&
--       \  result.current > result.maxcount
--         return printf(' /%s [>%d/>%d]', @/,
--         \             result.current, result.total)
--       elseif result.total > result.maxcount
--         return printf(' /%s [%d/>%d]', @/,
--         \             result.current, result.total)
--       endif
--     endif
--     return printf(' /%s [%d/%d]', @/,
--     \             result.current, result.total)
--   endfunction
--   let &statusline ..= '%{LastSearchCount()}'
-- 
--   " Or if you want to show the count only when
--   " 'hlsearch' was on
--   " let &statusline ..=
--   " \   '%{v:hlsearch ? LastSearchCount() : ""}'
-- ```
-- You can also update the search count, which can be useful in a
-- |CursorMoved| or |CursorMovedI| autocommand: 
-- ```vim
-- 
--   autocmd CursorMoved,CursorMovedI *
--     \ let s:searchcount_timer = timer_start(
--     \   200, function('s:update_searchcount'))
--   function! s:update_searchcount(timer) abort
--     if a:timer ==# s:searchcount_timer
--       call searchcount(#{
--       \ recompute: 1, maxcount: 0, timeout: 100})
--       redrawstatus
--     endif
--   endfunction
-- ```
-- This can also be used to count matched texts with specified
-- pattern in the current buffer using "pattern":  
-- ```vim
-- 
--   " Count '\<foo\>' in this buffer
--   " (Note that it also updates search count)
--   let result = searchcount(#{pattern: '\<foo\>'})
-- 
--   " To restore old search count by old pattern,
--   " search again
--   call searchcount()
-- ```
-- {options} must be a Dictionary. It can contain:
--   key    type    meaning ~
--   recompute  |Boolean|  if |TRUE|, recompute the count
--         like |n| or |N| was executed.
--         otherwise returns the last
--         computed result (when |n| or
--         |N| was used when "S" is not
--         in 'shortmess', or this
--         function was called).
--         (default: |TRUE|)
--   pattern  |String|  recompute if this was given
--         and different with |@/|.
--         this works as same as the
--         below command is executed
--         before calling this function 
-- ```vim
--           let @/ = pattern
-- ```
--         (default: |@/|)
--   timeout  |Number|  0 or negative number is no
--         timeout. timeout milliseconds
--         for recomputing the result
--         (default: 0)
--   maxcount  |Number|  0 or negative number is no
--         limit. max count of matched
--         text while recomputing the
--         result.  if search exceeded
--         total count, "total" value
--         becomes `maxcount + 1`
--         (default: 0)
--   pos    |List|    `[lnum, col, off]` value
--         when recomputing the result.
--         this changes "current" result
--         value. see |cursor()|, |getpos()|
--         (default: cursor's position)
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetSearchOpts()->searchcount()
-- ```
--- @param options? table<string, any>
--- @return table<string, any>
function vim.fn.searchcount(options) end

-- Search for the declaration of {name}.
-- 
-- With a non-zero {global} argument it works like |gD|, find
-- first match in the file.  Otherwise it works like |gd|, find
-- first match in the function.
-- 
-- With a non-zero {thisblock} argument matches in a {} block
-- that ends before the cursor position are ignored.  Avoids
-- finding variable declarations only valid in another scope.
-- 
-- Moves the cursor to the found match.
-- Returns zero for success, non-zero for failure.
-- Example: 
-- ```vim
--   if searchdecl('myvar') == 0
--      echo getline('.')
--   endif
-- ```
-- Can also be used as a |method|: 
-- ```vim
--   GetName()->searchdecl()
-- ```
--- @param global? any
--- @param thisblock? any
--- @return number
function vim.fn.searchdecl(name, global, thisblock) end

--   Search for the match of a nested start-end pair.  This can be
--   used to find the "endif" that matches an "if", while other
--   if/endif pairs in between are ignored.
--   The search starts at the cursor.  The default is to search
--   forward, include 'b' in {flags} to search backward.
--   If a match is found, the cursor is positioned at it and the
--   line number is returned.  If no match is found 0 or -1 is
--   returned and the cursor doesn't move.  No error message is
--   given.
-- 
--   {start}, {middle} and {end} are patterns, see |pattern|.  They
--   must not contain \( \) pairs.  Use of \%( \) is allowed.  When
--   {middle} is not empty, it is found when searching from either
--   direction, but only when not in a nested start-end pair.  A
--   typical use is: 
-- ```vim
--     searchpair('\<if\>', '\<else\>', '\<endif\>')
-- ```
--   By leaving {middle} empty the "else" is skipped.
-- 
--   {flags} 'b', 'c', 'n', 's', 'w' and 'W' are used like with
--   |search()|.  Additionally:
--   'r'  Repeat until no more matches found; will find the
--     outer pair.  Implies the 'W' flag.
--   'm'  Return number of matches instead of line number with
--     the match; will be > 1 when 'r' is used.
--   Note: it's nearly always a good idea to use the 'W' flag, to
--   avoid wrapping around the end of the file.
-- 
--   When a match for {start}, {middle} or {end} is found, the
--   {skip} expression is evaluated with the cursor positioned on
--   the start of the match.  It should return non-zero if this
--   match is to be skipped.  E.g., because it is inside a comment
--   or a string.
--   When {skip} is omitted or empty, every match is accepted.
--   When evaluating {skip} causes an error the search is aborted
--   and -1 returned.
--   {skip} can be a string, a lambda, a funcref or a partial.
--   Anything else makes the function fail.
-- 
--   For {stopline} and {timeout} see |search()|.
-- 
--   The value of 'ignorecase' is used.  'magic' is ignored, the
--   patterns are used like it's on.
-- 
--   The search starts exactly at the cursor.  A match with
--   {start}, {middle} or {end} at the next character, in the
--   direction of searching, is the first one found.  Example: 
-- ```vim
--     if 1
--       if 2
--       endif 2
--     endif 1
-- ```
--   When starting at the "if 2", with the cursor on the "i", and
--   searching forwards, the "endif 2" is found.  When starting on
--   the character just before the "if 2", the "endif 1" will be
--   found.  That's because the "if 2" will be found first, and
--   then this is considered to be a nested if/endif from "if 2" to
--   "endif 2".
--   When searching backwards and {end} is more than one character,
--   it may be useful to put "\zs" at the end of the pattern, so
--   that when the cursor is inside a match with the end it finds
--   the matching start.
-- 
--   Example, to find the "endif" command in a Vim script: 
-- ```vim
-- 
-- :echo searchpair('\<if\>', '\<el\%[seif]\>', '\<en\%[dif]\>', 'W',
--     \ 'getline(".") =~ "^\\s*\""')
-- 
-- ```
--   The cursor must be at or after the "if" for which a match is
--   to be found.  Note that single-quote strings are used to avoid
--   having to double the backslashes.  The skip expression only
--   catches comments at the start of a line, not after a command.
--   Also, a word "en" or "if" halfway through a line is considered
--   a match.
--   Another example, to search for the matching "{" of a "}": 
-- ```vim
-- 
-- :echo searchpair('{', '', '}', 'bW')
-- 
-- ```
--   This works when the cursor is at or before the "}" for which a
--   match is to be found.  To reject matches that syntax
--   highlighting recognized as strings: 
-- ```vim
-- 
-- :echo searchpair('{', '', '}', 'bW',
--      \ 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string"')
-- ```
--- @param start string
--- @param middle? string
--- @param end_ string
--- @param flags? string
--- @param skip? string
--- @param stopline? number
--- @param timeout? number
--- @return number
function vim.fn.searchpair(start, middle, end_, flags, skip, stopline, timeout) end

-- Same as |searchpair()|, but returns a |List| with the line and
-- column position of the match. The first element of the |List|
-- is the line number and the second element is the byte index of
-- the column position of the match.  If no match is found,
-- returns [0, 0]. 
-- ```vim
-- 
--   :let [lnum,col] = searchpairpos('{', '', '}', 'n')
-- ```
-- See |match-parens| for a bigger and more useful example.
--- @param start string
--- @param middle? string
--- @param end_ string
--- @param flags? string
--- @param skip? string
--- @param stopline? number
--- @param timeout? number
--- @return any[]
function vim.fn.searchpairpos(start, middle, end_, flags, skip, stopline, timeout) end

--   Same as |search()|, but returns a |List| with the line and
--   column position of the match. The first element of the |List|
--   is the line number and the second element is the byte index of
--   the column position of the match. If no match is found,
--   returns [0, 0].
--   Example: 
-- ```vim
-- :let [lnum, col] = searchpos('mypattern', 'n')
-- 
-- ```
--   When the 'p' flag is given then there is an extra item with
--   the sub-pattern match number |search()-sub-match|.  Example: 
-- ```vim
-- :let [lnum, col, submatch] = searchpos('\(\l\)\|\(\u\)', 'np')
-- ```
--   In this example "submatch" is 2 when a lowercase letter is
--   found |/\l|, 3 when an uppercase letter is found |/\u|.
-- 
--   Can also be used as a |method|: 
-- ```vim
--     GetPattern()->searchpos()
-- ```
--- @param flags? any
--- @param stopline? any
--- @param timeout? any
--- @param skip? any
--- @return any[]
function vim.fn.searchpos(pattern, flags, stopline, timeout, skip) end

-- Returns a list of server addresses, or empty if all servers
-- were stopped. |serverstart()| |serverstop()|
-- Example: 
-- ```vim
--   :echo serverlist()
-- ```
--- @return string
function vim.fn.serverlist() end

-- Opens a socket or named pipe at {address} and listens for
-- |RPC| messages. Clients can send |API| commands to the
-- returned address to control Nvim.
-- 
-- Returns the address string (which may differ from the
-- {address} argument, see below).
-- 
-- - If {address} has a colon (":") it is a TCP/IPv4/IPv6 address
--   where the last ":" separates host and port (empty or zero
--   assigns a random port).
-- - Else {address} is the path to a named pipe (except on Windows).
--   - If {address} has no slashes ("/") it is treated as the
--     "name" part of a generated path in this format: 
-- ```vim
--   stdpath("run").."/{name}.{pid}.{counter}"
-- ```
--   - If {address} is omitted the name is "nvim". >
--   :echo serverstart()
--   => /tmp/nvim.bram/oknANW/nvim.15430.5
-- 
-- <    Example bash command to list all Nvim servers: 
-- ```vim
--   ls ${XDG_RUNTIME_DIR:-${TMPDIR}nvim.${USER}}/.0
-- 
-- ```
-- Example named pipe: >
--   if has('win32')
--     echo serverstart('\\.\pipe\nvim-pipe-1234')
--   else
--     echo serverstart('nvim.sock')
--   endif
-- <
-- Example TCP/IP address: 
-- ```vim
--   echo serverstart('::1:12345')
-- ```
--- @param address? any
function vim.fn.serverstart(address) end

-- Closes the pipe or socket at {address}.
-- Returns TRUE if {address} is valid, else FALSE.
-- If |v:servername| is stopped it is set to the next available
-- address in |serverlist()|.
function vim.fn.serverstop(address) end

-- Set line {lnum} to {text} in buffer {buf}.  This works like
-- |setline()| for the specified buffer.
-- 
-- This function works only for loaded buffers. First call
-- |bufload()| if needed.
-- 
-- To insert lines use |appendbufline()|.
-- 
-- {text} can be a string to set one line, or a list of strings
-- to set multiple lines.  If the list extends below the last
-- line then those lines are added.
-- 
-- For the use of {buf}, see |bufname()| above.
-- 
-- {lnum} is used like with |setline()|.
-- Use "$" to refer to the last line in buffer {buf}.
-- When {lnum} is just below the last line the {text} will be
-- added below the last line.
-- On success 0 is returned, on failure 1 is returned.
-- 
-- If {buf} is not a valid buffer or {lnum} is not valid, an
-- error message is given.
-- 
-- Can also be used as a |method|, the base is passed as the
-- third argument: 
-- ```vim
--   GetText()->setbufline(buf, lnum)
-- ```
--- @param buf buffer
--- @param lnum number
--- @param text string
--- @return number
function vim.fn.setbufline(buf, lnum, text) end

-- Set option or local variable {varname} in buffer {buf} to
-- {val}.
-- This also works for a global or local window option, but it
-- doesn't work for a global or local window variable.
-- For a local window option the global value is unchanged.
-- For the use of {buf}, see |bufname()| above.
-- The {varname} argument is a string.
-- Note that the variable name without "b:" must be used.
-- Examples: 
-- ```vim
--   :call setbufvar(1, "&mod", 1)
--   :call setbufvar("todo", "myvar", "foobar")
-- ```
-- This function is not available in the |sandbox|.
-- 
-- Can also be used as a |method|, the base is passed as the
-- third argument: 
-- ```vim
--   GetValue()->setbufvar(buf, varname)
-- ```
--- @param buf buffer
--- @return boolean
function vim.fn.setbufvar(buf, varname, val) end

-- Specify overrides for cell widths of character ranges.  This
-- tells Vim how wide characters are when displayed in the
-- terminal, counted in screen cells.  The values override
-- 'ambiwidth'.  Example: 
-- ```vim
--    call setcellwidths([
--     \ [0x111, 0x111, 1],
--     \ [0x2194, 0x2199, 2],
--     \ ])
-- 
-- ```
-- The {list} argument is a List of Lists with each three
-- numbers: [{low}, {high}, {width}].
-- {low} and {high} can be the same, in which case this refers to
-- one character.  Otherwise it is the range of characters from
-- {low} to {high} (inclusive).
-- Only characters with value 0x80 and higher can be used.
-- 
-- {width} must be either 1 or 2, indicating the character width
-- in screen cells.
-- An error is given if the argument is invalid, also when a
-- range overlaps with another.
-- 
-- If the new value causes 'fillchars' or 'listchars' to become
-- invalid it is rejected and an error is given.
-- 
-- To clear the overrides pass an empty {list}: 
-- ```vim
--    call setcellwidths([])
-- 
-- ```
-- You can use the script $VIMRUNTIME/tools/emoji_list.vim to see
-- the effect for known emoji characters.  Move the cursor
-- through the text to check if the cell widths of your terminal
-- match with what Vim knows about each emoji.  If it doesn't
-- look right you need to adjust the {list} argument.
--- @param list any[]
function vim.fn.setcellwidths(list) end

-- Same as |setpos()| but uses the specified column number as the
-- character index instead of the byte index in the line.
-- 
-- Example:
-- With the text "여보세요" in line 8: 
-- ```vim
--   call setcharpos('.', [0, 8, 4, 0])
-- ```
-- positions the cursor on the fourth character '요'. >
--   call setpos('.', [0, 8, 4, 0])
-- <    positions the cursor on the second character '보'.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetPosition()->setcharpos('.')
-- ```
--- @param list any[]
--- @return number
function vim.fn.setcharpos(expr, list) end

-- Set the current character search information to {dict},
-- which contains one or more of the following entries:
-- 
--     char  character which will be used for a subsequent
--     |,| or |;| command; an empty string clears the
--     character search
--     forward  direction of character search; 1 for forward,
--     0 for backward
--     until  type of character search; 1 for a |t| or |T|
--     character search, 0 for an |f| or |F|
--     character search
-- 
-- This can be useful to save/restore a user's character search
-- from a script: 
-- ```vim
--   :let prevsearch = getcharsearch()
--   :" Perform a command which clobbers user's search
--   :call setcharsearch(prevsearch)
-- ```
-- Also see |getcharsearch()|.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   SavedSearch()->setcharsearch()
-- ```
--- @param dict table<string, any>
--- @return table<string, any>
function vim.fn.setcharsearch(dict) end

-- Set the command line to {str} and set the cursor position to
-- {pos}.
-- If {pos} is omitted, the cursor is positioned after the text.
-- Returns 0 when successful, 1 when not editing the command
-- line.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetText()->setcmdline()
-- ```
--- @param str string
--- @param pos? number
--- @return number
function vim.fn.setcmdline(str, pos) end

-- Set the cursor position in the command line to byte position
-- {pos}.  The first position is 1.
-- Use |getcmdpos()| to obtain the current position.
-- Only works while editing the command line, thus you must use
-- |c_CTRL-\_e|, |c_CTRL-R_=| or |c_CTRL-R_CTRL-R| with '='.  For
-- |c_CTRL-\_e| and |c_CTRL-R_CTRL-R| with '=' the position is
-- set after the command line is set to the expression.  For
-- |c_CTRL-R_=| it is set after evaluating the expression but
-- before inserting the resulting text.
-- When the number is too big the cursor is put at the end of the
-- line.  A number smaller than one has undefined results.
-- Returns 0 when successful, 1 when not editing the command
-- line.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetPos()->setcmdpos()
-- ```
--- @param pos number
--- @return number
function vim.fn.setcmdpos(pos) end

-- Same as |cursor()| but uses the specified column number as the
-- character index instead of the byte index in the line.
-- 
-- Example:
-- With the text "여보세요" in line 4: 
-- ```vim
--   call setcursorcharpos(4, 3)
-- ```
-- positions the cursor on the third character '세'. >
--   call cursor(4, 3)
-- <    positions the cursor on the first character '여'.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetCursorPos()->setcursorcharpos()
-- ```
--- @param list any[]
--- @return number
function vim.fn.setcursorcharpos(list) end

-- Set environment variable {name} to {val}.  Example: 
-- ```vim
--   call setenv('HOME', '/home/myhome')
-- 
-- ```
-- When {val} is |v:null| the environment variable is deleted.
-- See also |expr-env|.
-- 
-- Can also be used as a |method|, the base is passed as the
-- second argument: 
-- ```vim
--   GetPath()->setenv('PATH')
-- ```
function vim.fn.setenv(name, val) end

-- Set the file permissions for {fname} to {mode}.
-- {mode} must be a string with 9 characters.  It is of the form
-- "rwxrwxrwx", where each group of "rwx" flags represent, in
-- turn, the permissions of the owner of the file, the group the
-- file belongs to, and other users.  A '-' character means the
-- permission is off, any other character means on.  Multi-byte
-- characters are not supported.
-- 
-- For example "rw-r-----" means read-write for the user,
-- readable by the group, not accessible by others.  "xx-x-----"
-- would do the same thing.
-- 
-- Returns non-zero for success, zero for failure.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetFilename()->setfperm(mode)
-- ```
-- To read permissions see |getfperm()|.
function vim.fn.setfperm(fname, mode) end

-- Set line {lnum} of the current buffer to {text}.  To insert
-- lines use |append()|. To set lines in another buffer use
-- |setbufline()|.
-- 
-- {lnum} is used like with |getline()|.
-- When {lnum} is just below the last line the {text} will be
-- added below the last line.
-- {text} can be any type or a List of any type, each item is
-- converted to a String.
-- 
-- If this succeeds, FALSE is returned.  If this fails (most likely
-- because {lnum} is invalid) TRUE is returned.
-- 
-- Example: 
-- ```vim
--   :call setline(5, strftime("%c"))
-- 
-- ```
-- When {text} is a |List| then line {lnum} and following lines
-- will be set to the items in the list.  Example: 
-- ```vim
--   :call setline(5, ['aaa', 'bbb', 'ccc'])
-- ```
-- This is equivalent to: >
--   :for [n, l] in [[5, 'aaa'], [6, 'bbb'], [7, 'ccc']]
--   :  call setline(n, l)
--   :endfor
-- 
-- <    Note: The '[ and '] marks are not set.
-- 
-- Can also be used as a |method|, the base is passed as the
-- second argument: 
-- ```vim
--   GetText()->setline(lnum)
-- ```
--- @param lnum number
--- @param text string
--- @return number
function vim.fn.setline(lnum, text) end

-- Create or replace or add to the location list for window {nr}.
-- {nr} can be the window number or the |window-ID|.
-- When {nr} is zero the current window is used.
-- 
-- For a location list window, the displayed location list is
-- modified.  For an invalid window number {nr}, -1 is returned.
-- Otherwise, same as |setqflist()|.
-- Also see |location-list|.
-- 
-- For {action} see |setqflist-action|.
-- 
-- If the optional {what} dictionary argument is supplied, then
-- only the items listed in {what} are set. Refer to |setqflist()|
-- for the list of supported keys in {what}.
-- 
-- Can also be used as a |method|, the base is passed as the
-- second argument: 
-- ```vim
--   GetLoclist()->setloclist(winnr)
-- ```
--- @param nr number
--- @param list any[]
--- @param action? any
--- @param what? any
--- @return number
function vim.fn.setloclist(nr, list, action, what) end

-- Restores a list of matches saved by |getmatches()| for the
-- current window.  Returns 0 if successful, otherwise -1.  All
-- current matches are cleared before the list is restored.  See
-- example for |getmatches()|.
-- If {win} is specified, use the window with this number or
-- window ID instead of the current window.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetMatches()->setmatches()
-- ```
--- @param list any[]
--- @param win? window
--- @return number
function vim.fn.setmatches(list, win) end

-- Set the position for String {expr}.  Possible values:
--   .  the cursor
--   'x  mark x
-- 
-- {list} must be a |List| with four or five numbers:
--     [bufnum, lnum, col, off]
--     [bufnum, lnum, col, off, curswant]
-- 
-- "bufnum" is the buffer number.  Zero can be used for the
-- current buffer.  When setting an uppercase mark "bufnum" is
-- used for the mark position.  For other marks it specifies the
-- buffer to set the mark in.  You can use the |bufnr()| function
-- to turn a file name into a buffer number.
-- For setting the cursor and the ' mark "bufnum" is ignored,
-- since these are associated with a window, not a buffer.
-- Does not change the jumplist.
-- 
-- "lnum" and "col" are the position in the buffer.  The first
-- column is 1.  Use a zero "lnum" to delete a mark.  If "col" is
-- smaller than 1 then 1 is used. To use the character count
-- instead of the byte count, use |setcharpos()|.
-- 
-- The "off" number is only used when 'virtualedit' is set. Then
-- it is the offset in screen columns from the start of the
-- character.  E.g., a position within a <Tab> or after the last
-- character.
-- 
-- The "curswant" number is only used when setting the cursor
-- position.  It sets the preferred column for when moving the
-- cursor vertically.  When the "curswant" number is missing the
-- preferred column is not set.  When it is present and setting a
-- mark position it is not used.
-- 
-- Note that for '< and '> changing the line number may result in
-- the marks to be effectively be swapped, so that '< is always
-- before '>.
-- 
-- Returns 0 when the position could be set, -1 otherwise.
-- An error message is given if {expr} is invalid.
-- 
-- Also see |setcharpos()|, |getpos()| and |getcurpos()|.
-- 
-- This does not restore the preferred column for moving
-- vertically; if you set the cursor position with this, |j| and
-- |k| motions will jump to previous columns!  Use |cursor()| to
-- also set the preferred column.  Also see the "curswant" key in
-- |winrestview()|.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetPosition()->setpos('.')
-- ```
--- @param list any[]
--- @return number
function vim.fn.setpos(expr, list) end

-- Create or replace or add to the quickfix list.
-- 
-- If the optional {what} dictionary argument is supplied, then
-- only the items listed in {what} are set. The first {list}
-- argument is ignored.  See below for the supported items in
-- {what}.
-- 
-- When {what} is not present, the items in {list} are used.  Each
-- item must be a dictionary.  Non-dictionary items in {list} are
-- ignored.  Each dictionary item can contain the following
-- entries:
-- 
--     bufnr  buffer number; must be the number of a valid
--     buffer
--     filename  name of a file; only used when "bufnr" is not
--     present or it is invalid.
--     module  name of a module; if given it will be used in
--     quickfix error window instead of the filename.
--     lnum  line number in the file
--     end_lnum  end of lines, if the item spans multiple lines
--     pattern  search pattern used to locate the error
--     col    column number
--     vcol  when non-zero: "col" is visual column
--     when zero: "col" is byte index
--     end_col  end column, if the item spans multiple columns
--     nr    error number
--     text  description of the error
--     type  single-character error type, 'E', 'W', etc.
--     valid  recognized error message
-- 
-- The "col", "vcol", "nr", "type" and "text" entries are
-- optional.  Either "lnum" or "pattern" entry can be used to
-- locate a matching error line.
-- If the "filename" and "bufnr" entries are not present or
-- neither the "lnum" or "pattern" entries are present, then the
-- item will not be handled as an error line.
-- If both "pattern" and "lnum" are present then "pattern" will
-- be used.
-- If the "valid" entry is not supplied, then the valid flag is
-- set when "bufnr" is a valid buffer or "filename" exists.
-- If you supply an empty {list}, the quickfix list will be
-- cleared.
-- Note that the list is not exactly the same as what
-- |getqflist()| returns.
-- 
-- {action} values:
-- 'a'  The items from {list} are added to the existing
--   quickfix list. If there is no existing list, then a
--   new list is created.
-- 
-- 'r'  The items from the current quickfix list are replaced
--   with the items from {list}.  This can also be used to
--   clear the list: 
-- ```vim
--     :call setqflist([], 'r')
-- ```
-- 'f'  All the quickfix lists in the quickfix stack are
--   freed.
-- 
-- If {action} is not present or is set to ' ', then a new list
-- is created. The new quickfix list is added after the current
-- quickfix list in the stack and all the following lists are
-- freed. To add a new quickfix list at the end of the stack,
-- set "nr" in {what} to "$".
-- 
-- The following items can be specified in dictionary {what}:
--     context  quickfix list context. See |quickfix-context|
--     efm    errorformat to use when parsing text from
--     "lines". If this is not present, then the
--     'errorformat' option value is used.
--     See |quickfix-parse|
--     id    quickfix list identifier |quickfix-ID|
--     idx    index of the current entry in the quickfix
--     list specified by "id" or "nr". If set to '$',
--     then the last entry in the list is set as the
--     current entry.  See |quickfix-index|
--     items  list of quickfix entries. Same as the {list}
--     argument.
--     lines  use 'errorformat' to parse a list of lines and
--     add the resulting entries to the quickfix list
--     {nr} or {id}.  Only a |List| value is supported.
--     See |quickfix-parse|
--     nr    list number in the quickfix stack; zero
--     means the current quickfix list and "$" means
--     the last quickfix list.
--     quickfixtextfunc
--     function to get the text to display in the
--     quickfix window.  The value can be the name of
--     a function or a funcref or a lambda.  Refer to
--     |quickfix-window-function| for an explanation
--     of how to write the function and an example.
--     title  quickfix list title text. See |quickfix-title|
-- Unsupported keys in {what} are ignored.
-- If the "nr" item is not present, then the current quickfix list
-- is modified. When creating a new quickfix list, "nr" can be
-- set to a value one greater than the quickfix stack size.
-- When modifying a quickfix list, to guarantee that the correct
-- list is modified, "id" should be used instead of "nr" to
-- specify the list.
-- 
-- Examples (See also |setqflist-examples|): 
-- ```vim
--    :call setqflist([], 'r', {'title': 'My search'})
--    :call setqflist([], 'r', {'nr': 2, 'title': 'Errors'})
--    :call setqflist([], 'a', {'id':qfid, 'lines':["F1:10:L10"]})
-- ```
-- Returns zero for success, -1 for failure.
-- 
-- This function can be used to create a quickfix list
-- independent of the 'errorformat' setting.  Use a command like
-- `:cc 1` to jump to the first position.
-- 
-- Can also be used as a |method|, the base is passed as the
-- second argument: 
-- ```vim
--   GetErrorlist()->setqflist()
-- ```
--- @param list any[]
--- @param action? any
--- @param what? any
--- @return number
function vim.fn.setqflist(list, action, what) end

-- Set the register {regname} to {value}.
-- If {regname} is "" or "@", the unnamed register '"' is used.
-- The {regname} argument is a string.
-- 
-- {value} may be any value returned by |getreg()| or
-- |getreginfo()|, including a |List| or |Dict|.
-- If {options} contains "a" or {regname} is upper case,
-- then the value is appended.
-- 
-- {options} can also contain a register type specification:
--     "c" or "v"        |charwise| mode
--     "l" or "V"        |linewise| mode
--     "b" or "<CTRL-V>" |blockwise-visual| mode
-- If a number immediately follows "b" or "<CTRL-V>" then this is
-- used as the width of the selection - if it is not specified
-- then the width of the block is set to the number of characters
-- in the longest line (counting a <Tab> as 1 character).
-- If {options} contains "u" or '"', then the unnamed register is
-- set to point to register {regname}.
-- 
-- If {options} contains no register settings, then the default
-- is to use character mode unless {value} ends in a <NL> for
-- string {value} and linewise mode for list {value}. Blockwise
-- mode is never selected automatically.
-- Returns zero for success, non-zero for failure.
-- 
-- 
-- Note: you may not use |List| containing more than one item to
--       set search and expression registers. Lists containing no
--       items act like empty strings.
-- 
-- Examples: 
-- ```vim
--   :call setreg(v:register, @*)
--   :call setreg('*', @%, 'ac')
--   :call setreg('a', "1\n2\n3", 'b5')
--   :call setreg('"', { 'points_to': 'a'})
-- 
-- ```
-- This example shows using the functions to save and restore a
-- register: 
-- ```vim
--   :let var_a = getreginfo()
--   :call setreg('a', var_a)
-- ```
-- or: >
--   :let var_a = getreg('a', 1, 1)
--   :let var_amode = getregtype('a')
--       ....
--   :call setreg('a', var_a, var_amode)
-- <    Note: you may not reliably restore register value
-- without using the third argument to |getreg()| as without it
-- newlines are represented as newlines AND Nul bytes are
-- represented as newlines as well, see |NL-used-for-Nul|.
-- 
-- You can also change the type of a register by appending
-- nothing: 
-- ```vim
--   :call setreg('a', '', 'al')
-- 
-- ```
-- Can also be used as a |method|, the base is passed as the
-- second argument: 
-- ```vim
--   GetText()->setreg('a')
-- ```
--- @param options? table<string, any>
--- @return number
function vim.fn.setreg(regname, value, options) end

-- Set tab-local variable {varname} to {val} in tab page {tabnr}.
-- |t:var|
-- The {varname} argument is a string.
-- Note that the variable name without "t:" must be used.
-- Tabs are numbered starting with one.
-- This function is not available in the |sandbox|.
-- 
-- Can also be used as a |method|, the base is passed as the
-- third argument: 
-- ```vim
--   GetValue()->settabvar(tab, name)
-- ```
--- @param tabnr number
--- @return boolean
function vim.fn.settabvar(tabnr, varname, val) end

-- Set option or local variable {varname} in window {winnr} to
-- {val}.
-- Tabs are numbered starting with one.  For the current tabpage
-- use |setwinvar()|.
-- {winnr} can be the window number or the |window-ID|.
-- When {winnr} is zero the current window is used.
-- This also works for a global or local buffer option, but it
-- doesn't work for a global or local buffer variable.
-- For a local buffer option the global value is unchanged.
-- Note that the variable name without "w:" must be used.
-- Examples: 
-- ```vim
--   :call settabwinvar(1, 1, "&list", 0)
--   :call settabwinvar(3, 2, "myvar", "foobar")
-- ```
-- This function is not available in the |sandbox|.
-- 
-- Can also be used as a |method|, the base is passed as the
-- fourth argument: 
-- ```vim
--   GetValue()->settabwinvar(tab, winnr, name)
-- ```
--- @param tabnr number
--- @param winnr window
--- @return boolean
function vim.fn.settabwinvar(tabnr, winnr, varname, val) end

-- Modify the tag stack of the window {nr} using {dict}.
-- {nr} can be the window number or the |window-ID|.
-- 
-- For a list of supported items in {dict}, refer to
-- |gettagstack()|. "curidx" takes effect before changing the tag
-- stack.
-- 
-- How the tag stack is modified depends on the {action}
-- argument:
-- - If {action} is not present or is set to 'r', then the tag
--   stack is replaced.
-- - If {action} is set to 'a', then new entries from {dict} are
--   pushed (added) onto the tag stack.
-- - If {action} is set to 't', then all the entries from the
--   current entry in the tag stack or "curidx" in {dict} are
--   removed and then new entries are pushed to the stack.
-- 
-- The current index is set to one after the length of the tag
-- stack after the modification.
-- 
-- Returns zero for success, -1 for failure.
-- 
-- Examples (for more examples see |tagstack-examples|):
--     Empty the tag stack of window 3: 
-- ```vim
--   call settagstack(3, {'items' : []})
-- 
-- ```
--     Save and restore the tag stack: >
--   let stack = gettagstack(1003)
--   " do something else
--   call settagstack(1003, stack)
--   unlet stack
-- <
-- Can also be used as a |method|, the base is passed as the
-- second argument: 
-- ```vim
--   GetStack()->settagstack(winnr)
-- ```
--- @param nr number
--- @param dict table<string, any>
--- @param action? any
--- @return number
function vim.fn.settagstack(nr, dict, action) end

-- Like |settabwinvar()| for the current tab page.
-- Examples: 
-- ```vim
--   :call setwinvar(1, "&list", 0)
--   :call setwinvar(2, "myvar", "foobar")
-- 
-- ```
-- Can also be used as a |method|, the base is passed as the
-- third argument: 
-- ```vim
--   GetValue()->setwinvar(winnr, name)
-- ```
--- @param nr number
--- @return boolean
function vim.fn.setwinvar(nr, varname, val) end

-- Returns a String with 64 hex characters, which is the SHA256
-- checksum of {string}.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetText()->sha256()
-- ```
--- @param string string
--- @return string
function vim.fn.sha256(string) end

-- Escape {string} for use as a shell command argument.
-- 
-- On Windows when 'shellslash' is not set, encloses {string} in
-- double-quotes and doubles all double-quotes within {string}.
-- Otherwise encloses {string} in single-quotes and replaces all
-- "'" with "'\''".
-- 
-- If {special} is a |non-zero-arg|:
-- - Special items such as "!", "%", "#" and "<cword>" will be
--   preceded by a backslash. The backslash will be removed again
--   by the |:!| command.
-- - The <NL> character is escaped.
-- 
-- If 'shell' contains "csh" in the tail:
-- - The "!" character will be escaped. This is because csh and
--   tcsh use "!" for history replacement even in single-quotes.
-- - The <NL> character is escaped (twice if {special} is
--   a |non-zero-arg|).
-- 
-- If 'shell' contains "fish" in the tail, the "\" character will
-- be escaped because in fish it is used as an escape character
-- inside single quotes.
-- 
-- Example of use with a |:!| command: 
-- ```vim
--     :exe '!dir ' .. shellescape(expand('<cfile>'), 1)
-- ```
-- This results in a directory listing for the file under the
-- cursor.  Example of use with |system()|: 
-- ```vim
--     :call system("chmod +w -- " .. shellescape(expand("%")))
-- ```
-- See also |::S|.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetCommand()->shellescape()
-- ```
--- @param string string
--- @param special? any
--- @return string
function vim.fn.shellescape(string, special) end

-- Returns the effective value of 'shiftwidth'. This is the
-- 'shiftwidth' value unless it is zero, in which case it is the
-- 'tabstop' value.  To be backwards compatible in indent
-- plugins, use this: 
-- ```vim
--   if exists('*shiftwidth')
--     func s:sw()
--       return shiftwidth()
--     endfunc
--   else
--     func s:sw()
--       return &sw
--     endfunc
--   endif
-- ```
-- And then use s:sw() instead of &sw.
-- 
-- When there is one argument {col} this is used as column number
-- for which to return the 'shiftwidth' value. This matters for the
-- 'vartabstop' feature. If no {col} argument is given, column 1
-- will be assumed.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetColumn()->shiftwidth()
-- ```
--- @param col? number
--- @return number
function vim.fn.shiftwidth(col) end

-- List  define or update a list of signs
--- @param list any[]
--- @return any[]
--- @overload fun(name:string, dict?:table)
function vim.fn.sign_define(list) end

-- List  get a list of defined signs
--- @param name? any
--- @return any[]
function vim.fn.sign_getdefined(name) end

-- List  get a list of placed signs
--- @param buf? buffer
--- @param dict? table<string, any>
--- @return any[]
function vim.fn.sign_getplaced(buf, dict) end

-- Number  jump to a sign
--- @param buf buffer
--- @return number
function vim.fn.sign_jump(id, group, buf) end

-- Number  place a sign
--- @param buf buffer
--- @param dict? table<string, any>
--- @return number
function vim.fn.sign_place(id, group, name, buf, dict) end

-- List  place a list of signs
--- @param list any[]
--- @return any[]
function vim.fn.sign_placelist(list) end

-- List  undefine a list of signs
--- @param list any[]
--- @return any[]
function vim.fn.sign_undefine(list) end

-- Number  unplace a sign
--- @param dict? table<string, any>
--- @return number
function vim.fn.sign_unplace(group, dict) end

-- List  unplace a list of signs
--- @param list any[]
--- @return any[]
function vim.fn.sign_unplacelist(list) end

-- Simplify the file name as much as possible without changing
-- the meaning.  Shortcuts (on MS-Windows) or symbolic links (on
-- Unix) are not resolved.  If the first path component in
-- {filename} designates the current directory, this will be
-- valid for the result as well.  A trailing path separator is
-- not removed either. On Unix "//path" is unchanged, but
-- "///path" is simplified to "/path" (this follows the Posix
-- standard).
-- Example: 
-- ```vim
--   simplify("./dir/.././/file/") == "./file/"
-- ```
-- Note: The combination "dir/.." is only removed if "dir" is
-- a searchable directory or does not exist.  On Unix, it is also
-- removed when "dir" is a symbolic link within the same
-- directory.  In order to resolve all the involved symbolic
-- links before simplifying the path name, use |resolve()|.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetName()->simplify()
-- ```
--- @return string
function vim.fn.simplify(filename) end

-- Return the sine of {expr}, measured in radians, as a |Float|.
-- {expr} must evaluate to a |Float| or a |Number|.
-- Returns 0.0 if {expr} is not a |Float| or a |Number|.
-- Examples: 
-- ```vim
--   :echo sin(100)
-- ```
--   -0.506366 >
--   :echo sin(-4.01)
-- <      0.763301
-- 
-- Can also be used as a |method|: 
-- ```vim
--   Compute()->sin()
-- ```
--- @return float
function vim.fn.sin(expr) end

-- Return the hyperbolic sine of {expr} as a |Float| in the range
-- [-inf, inf].
-- {expr} must evaluate to a |Float| or a |Number|.
-- Returns 0.0 if {expr} is not a |Float| or a |Number|.
-- Examples: 
-- ```vim
--   :echo sinh(0.5)
-- ```
--   0.521095 >
--   :echo sinh(-0.9)
-- <      -1.026517
-- 
-- Can also be used as a |method|: 
-- ```vim
--   Compute()->sinh()
-- ```
--- @return float
function vim.fn.sinh(expr) end

-- Similar to using a |slice| "expr[start : end]", but "end" is
-- used exclusive.  And for a string the indexes are used as
-- character indexes instead of byte indexes.
-- Also, composing characters are not counted.
-- When {end} is omitted the slice continues to the last item.
-- When {end} is -1 the last item is omitted.
-- Returns an empty value if {start} or {end} are invalid.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetList()->slice(offset)
-- ```
--- @param start number
--- @param end_? number
--- @return string
function vim.fn.slice(expr, start, end_) end

-- Connect a socket to an address. If {mode} is "pipe" then
-- {address} should be the path of a local domain socket (on
-- unix) or named pipe (on Windows). If {mode} is "tcp" then
-- {address} should be of the form "host:port" where the host
-- should be an ip adderess or host name, and port the port
-- number.
-- 
-- For "pipe" mode, see |luv-pipe-handle|. For "tcp" mode, see
-- |luv-tcp-handle|.
-- 
-- Returns a |channel| ID. Close the socket with |chanclose()|.
-- Use |chansend()| to send data over a bytes socket, and
-- |rpcrequest()| and |rpcnotify()| to communicate with a RPC
-- socket.
-- 
-- {opts} is an optional dictionary with these keys:
--   |on_data| : callback invoked when data was read from socket
--   data_buffered : read socket data in |channel-buffered| mode.
--   rpc     : If set, |msgpack-rpc| will be used to communicate
--       over the socket.
-- Returns:
--   - The channel ID on success (greater than zero)
--   - 0 on invalid arguments or connection failure.
--- @param opts? table<string, any>
--- @return number
function vim.fn.sockconnect(mode, address, opts) end

-- Sort the items in {list} in-place.  Returns {list}.
-- 
-- If you want a list to remain unmodified make a copy first: 
-- ```vim
--   :let sortedlist = sort(copy(mylist))
-- 
-- ```
-- When {func} is omitted, is empty or zero, then sort() uses the
-- string representation of each item to sort on.  Numbers sort
-- after Strings, |Lists| after Numbers.  For sorting text in the
-- current buffer use |:sort|.
-- 
-- When {func} is given and it is '1' or 'i' then case is
-- ignored.
-- 
-- When {func} is given and it is 'l' then the current collation
-- locale is used for ordering. Implementation details: strcoll()
-- is used to compare strings. See |:language| check or set the
-- collation locale. |v:collate| can also be used to check the
-- current locale. Sorting using the locale typically ignores
-- case. Example: 
-- ```vim
--   " ö is sorted similarly to o with English locale.
--   :language collate en_US.UTF8
--   :echo sort(['n', 'o', 'O', 'ö', 'p', 'z'], 'l')
-- ```
--   ['n', 'o', 'O', 'ö', 'p', 'z'] ~
-- ```vim
--   " ö is sorted after z with Swedish locale.
--   :language collate sv_SE.UTF8
--   :echo sort(['n', 'o', 'O', 'ö', 'p', 'z'], 'l')
-- ```
--   ['n', 'o', 'O', 'p', 'z', 'ö'] ~
-- This does not work properly on Mac.
-- 
-- When {func} is given and it is 'n' then all items will be
-- sorted numerical (Implementation detail: this uses the
-- strtod() function to parse numbers, Strings, Lists, Dicts and
-- Funcrefs will be considered as being 0).
-- 
-- When {func} is given and it is 'N' then all items will be
-- sorted numerical. This is like 'n' but a string containing
-- digits will be used as the number they represent.
-- 
-- When {func} is given and it is 'f' then all items will be
-- sorted numerical. All values must be a Number or a Float.
-- 
-- When {func} is a |Funcref| or a function name, this function
-- is called to compare items.  The function is invoked with two
-- items as argument and must return zero if they are equal, 1 or
-- bigger if the first one sorts after the second one, -1 or
-- smaller if the first one sorts before the second one.
-- 
-- {dict} is for functions with the "dict" attribute.  It will be
-- used to set the local variable "self". |Dictionary-function|
-- 
-- The sort is stable, items which compare equal (as number or as
-- string) will keep their relative position. E.g., when sorting
-- on numbers, text strings will sort next to each other, in the
-- same order as they were originally.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   mylist->sort()
-- 
-- ```
-- Also see |uniq()|.
-- 
-- Example: 
-- ```vim
--   func MyCompare(i1, i2)
--      return a:i1 == a:i2 ? 0 : a:i1 > a:i2 ? 1 : -1
--   endfunc
--   eval mylist->sort("MyCompare")
-- ```
-- A shorter compare version for this specific simple case, which
-- ignores overflow: 
-- ```vim
--   func MyCompare(i1, i2)
--      return a:i1 - a:i2
--   endfunc
-- ```
-- For a simple expression you can use a lambda: >
--   eval mylist->sort({i1, i2 -> i1 - i2})
-- <
--- @param list any[]
--- @param func? fun()
--- @param dict? table<string, any>
--- @return any[]
function vim.fn.sort(list, func, dict) end

-- Return the sound-folded equivalent of {word}.  Uses the first
-- language in 'spelllang' for the current window that supports
-- soundfolding.  'spell' must be set.  When no sound folding is
-- possible the {word} is returned unmodified.
-- This can be used for making spelling suggestions.  Note that
-- the method can be quite slow.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetWord()->soundfold()
-- ```
--- @return string
function vim.fn.soundfold(word) end

-- Without argument: The result is the badly spelled word under
-- or after the cursor.  The cursor is moved to the start of the
-- bad word.  When no bad word is found in the cursor line the
-- result is an empty string and the cursor doesn't move.
-- 
-- With argument: The result is the first word in {sentence} that
-- is badly spelled.  If there are no spelling mistakes the
-- result is an empty string.
-- 
-- The return value is a list with two items:
-- - The badly spelled word or an empty string.
-- - The type of the spelling error:
--   "bad"    spelling mistake
--   "rare"    rare word
--   "local"    word only valid in another region
--   "caps"    word should start with Capital
-- Example: 
-- ```vim
--   echo spellbadword("the quik brown fox")
-- ```
--   ['quik', 'bad'] ~
-- 
-- The spelling information for the current window and the value
-- of 'spelllang' are used.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetText()->spellbadword()
-- ```
--- @param sentence? any
--- @return string
function vim.fn.spellbadword(sentence) end

-- Return a |List| with spelling suggestions to replace {word}.
-- When {max} is given up to this number of suggestions are
-- returned.  Otherwise up to 25 suggestions are returned.
-- 
-- When the {capital} argument is given and it's non-zero only
-- suggestions with a leading capital will be given.  Use this
-- after a match with 'spellcapcheck'.
-- 
-- {word} can be a badly spelled word followed by other text.
-- This allows for joining two words that were split.  The
-- suggestions also include the following text, thus you can
-- replace a line.
-- 
-- {word} may also be a good word.  Similar words will then be
-- returned.  {word} itself is not included in the suggestions,
-- although it may appear capitalized.
-- 
-- The spelling information for the current window is used.  The
-- values of 'spelllang' and 'spellsuggest' are used.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetWord()->spellsuggest()
-- ```
--- @param max? any
--- @param capital? any
--- @return any[]
function vim.fn.spellsuggest(word, max, capital) end

-- Make a |List| out of {string}.  When {pattern} is omitted or
-- empty each white-separated sequence of characters becomes an
-- item.
-- Otherwise the string is split where {pattern} matches,
-- removing the matched characters. 'ignorecase' is not used
-- here, add \c to ignore case. |/\c|
-- When the first or last item is empty it is omitted, unless the
-- {keepempty} argument is given and it's non-zero.
-- Other empty items are kept when {pattern} matches at least one
-- character or when {keepempty} is non-zero.
-- Example: 
-- ```vim
--   :let words = split(getline('.'), '\W\+')
-- ```
-- To split a string in individual characters: >
--   :for c in split(mystring, '\zs')
-- <    If you want to keep the separator you can also use '\zs' at
-- the end of the pattern: 
-- ```vim
--   :echo split('abc:def:ghi', ':\zs')
-- ```
--   ['abc:', 'def:', 'ghi'] ~
-- Splitting a table where the first element can be empty: 
-- ```vim
--   :let items = split(line, ':', 1)
-- ```
-- The opposite function is |join()|.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetString()->split()
-- ```
--- @param string string
--- @param pattern? any
--- @param keepempty? any
--- @return any[]
function vim.fn.split(string, pattern, keepempty) end

-- Return the non-negative square root of Float {expr} as a
-- |Float|.
-- {expr} must evaluate to a |Float| or a |Number|.  When {expr}
-- is negative the result is NaN (Not a Number).  Returns 0.0 if
-- {expr} is not a |Float| or a |Number|.
-- Examples: 
-- ```vim
--   :echo sqrt(100)
-- ```
--   10.0 >
--   :echo sqrt(-4.01)
-- <      str2float("nan")
-- NaN may be different, it depends on system libraries.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   Compute()->sqrt()
-- ```
--- @return float
function vim.fn.sqrt(expr) end

-- Initialize seed used by |rand()|:
-- - If {expr} is not given, seed values are initialized by
--   reading from /dev/urandom, if possible, or using time(NULL)
--   a.k.a. epoch time otherwise; this only has second accuracy.
-- - If {expr} is given it must be a Number.  It is used to
--   initialize the seed values.  This is useful for testing or
--   when a predictable sequence is intended.
-- 
-- Examples: 
-- ```vim
--   :let seed = srand()
--   :let seed = srand(userinput)
--   :echo rand(seed)
-- ```
-- Can also be used as a |method|: 
-- ```vim
--   userinput->srand()
-- ```
--- @param expr? any
--- @return any[]
function vim.fn.srand(expr) end

-- With |--headless| this opens stdin and stdout as a |channel|.
-- May be called only once. See |channel-stdio|. stderr is not
-- handled by this function, see |v:stderr|.
-- 
-- Close the stdio handles with |chanclose()|. Use |chansend()|
-- to send data to stdout, and |rpcrequest()| and |rpcnotify()|
-- to communicate over RPC.
-- 
-- {opts} is a dictionary with these keys:
--   |on_stdin| : callback invoked when stdin is written to.
--   on_print : callback invoked when Nvim needs to print a
--        message, with the message (whose type is string)
--        as sole argument.
--   stdin_buffered : read stdin in |channel-buffered| mode.
--   rpc      : If set, |msgpack-rpc| will be used to communicate
--        over stdio
-- Returns:
--   - |channel-id| on success (value is always 1)
--   - 0 on invalid arguments
--- @param opts table<string, any>
--- @return number
function vim.fn.stdioopen(opts) end

-- Returns |standard-path| locations of various default files and
-- directories.
-- 
-- {what}       Type    Description ~
-- cache        String  Cache directory: arbitrary temporary
--                      storage for plugins, etc.
-- config       String  User configuration directory. |init.vim|
--                      is stored here.
-- config_dirs  List    Other configuration directories.
-- data         String  User data directory.
-- data_dirs    List    Other data directories.
-- log          String  Logs directory (for use by plugins too).
-- run          String  Run directory: temporary, local storage
--          for sockets, named pipes, etc.
-- state        String  Session state directory: storage for file
--          drafts, swap, undo, |shada|.
-- 
-- Example: 
-- ```vim
--   :echo stdpath("config")
-- ```
--- @return string
function vim.fn.stdpath(what) end

-- Convert String {string} to a Float.  This mostly works the
-- same as when using a floating point number in an expression,
-- see |floating-point-format|.  But it's a bit more permissive.
-- E.g., "1e40" is accepted, while in an expression you need to
-- write "1.0e40".  The hexadecimal form "0x123" is also
-- accepted, but not others, like binary or octal.
-- When {quoted} is present and non-zero then embedded single
-- quotes before the dot are ignored, thus "1'000.0" is a
-- thousand.
-- Text after the number is silently ignored.
-- The decimal point is always '.', no matter what the locale is
-- set to.  A comma ends the number: "12,345.67" is converted to
-- 12.0.  You can strip out thousands separators with
-- |substitute()|: 
-- ```vim
--   let f = str2float(substitute(text, ',', '', 'g'))
-- ```
-- Returns 0.0 if the conversion fails.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   let f = text->substitute(',', '', 'g')->str2float()
-- ```
--- @param string string
--- @param quoted? any
--- @return float
function vim.fn.str2float(string, quoted) end

-- Return a list containing the number values which represent
-- each character in String {string}.  Examples: 
-- ```vim
--   str2list(" ")    returns [32]
--   str2list("ABC")    returns [65, 66, 67]
-- ```
-- |list2str()| does the opposite.
-- 
-- UTF-8 encoding is always used, {utf8} option has no effect,
-- and exists only for backwards-compatibility.
-- With UTF-8 composing characters are handled properly: 
-- ```vim
--   str2list("á")    returns [97, 769]
-- 
-- ```
-- Can also be used as a |method|: >
--   GetString()->str2list()
--- @param string string
--- @param utf8? any
--- @return any[]
function vim.fn.str2list(string, utf8) end

-- Convert string {string} to a number.
-- {base} is the conversion base, it can be 2, 8, 10 or 16.
-- When {quoted} is present and non-zero then embedded single
-- quotes are ignored, thus "1'000'000" is a million.
-- 
-- When {base} is omitted base 10 is used.  This also means that
-- a leading zero doesn't cause octal conversion to be used, as
-- with the default String to Number conversion.  Example: 
-- ```vim
--   let nr = str2nr('0123')
-- ```
-- When {base} is 16 a leading "0x" or "0X" is ignored.  With a
-- different base the result will be zero. Similarly, when
-- {base} is 8 a leading "0", "0o" or "0O" is ignored, and when
-- {base} is 2 a leading "0b" or "0B" is ignored.
-- Text after the number is silently ignored.
-- 
-- Returns 0 if {string} is empty or on error.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetText()->str2nr()
-- ```
--- @param string string
--- @param base? any
--- @return number
function vim.fn.str2nr(string, base) end

-- The result is a Number, which is the number of characters
-- in String {string}.  Composing characters are ignored.
-- |strchars()| can count the number of characters, counting
-- composing characters separately.
-- 
-- Returns 0 if {string} is empty or on error.
-- 
-- Also see |strlen()|, |strdisplaywidth()| and |strwidth()|.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetText()->strcharlen()
-- ```
--- @param string string
--- @return number
function vim.fn.strcharlen(string) end

-- Like |strpart()| but using character index and length instead
-- of byte index and length.
-- When {skipcc} is omitted or zero, composing characters are
-- counted separately.
-- When {skipcc} set to 1, Composing characters are ignored,
-- similar to  |slice()|.
-- When a character index is used where a character does not
-- exist it is omitted and counted as one character.  For
-- example: 
-- ```vim
--   strcharpart('abc', -1, 2)
-- ```
-- results in 'a'.
-- 
-- Returns an empty string on error.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetText()->strcharpart(5)
-- ```
--- @param start number
--- @param len? any
--- @param skipcc? any
--- @return string
function vim.fn.strcharpart(src, start, len, skipcc) end

-- The result is a Number, which is the number of characters
-- in String {string}.
-- When {skipcc} is omitted or zero, composing characters are
-- counted separately.
-- When {skipcc} set to 1, Composing characters are ignored.
-- |strcharlen()| always does this.
-- 
-- Returns zero on error.
-- 
-- Also see |strlen()|, |strdisplaywidth()| and |strwidth()|.
-- 
-- {skipcc} is only available after 7.4.755.  For backward
-- compatibility, you can define a wrapper function: 
-- ```vim
--     if has("patch-7.4.755")
--       function s:strchars(str, skipcc)
--   return strchars(a:str, a:skipcc)
--       endfunction
--     else
--       function s:strchars(str, skipcc)
--   if a:skipcc
--     return strlen(substitute(a:str, ".", "x", "g"))
--   else
--     return strchars(a:str)
--   endif
--       endfunction
--     endif
-- ```
-- Can also be used as a |method|: 
-- ```vim
--   GetText()->strchars()
-- ```
--- @param string string
--- @param skipcc? any
--- @return number
function vim.fn.strchars(string, skipcc) end

-- The result is a Number, which is the number of display cells
-- String {string} occupies on the screen when it starts at {col}
-- (first column is zero).  When {col} is omitted zero is used.
-- Otherwise it is the screen column where to start.  This
-- matters for Tab characters.
-- The option settings of the current window are used.  This
-- matters for anything that's displayed differently, such as
-- 'tabstop' and 'display'.
-- When {string} contains characters with East Asian Width Class
-- Ambiguous, this function's return value depends on 'ambiwidth'.
-- Returns zero on error.
-- Also see |strlen()|, |strwidth()| and |strchars()|.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetText()->strdisplaywidth()
-- ```
--- @param string string
--- @param col? number
--- @return number
function vim.fn.strdisplaywidth(string, col) end

-- The result is a String, which is a formatted date and time, as
-- specified by the {format} string.  The given {time} is used,
-- or the current time if no time is given.  The accepted
-- {format} depends on your system, thus this is not portable!
-- See the manual page of the C function strftime() for the
-- format.  The maximum length of the result is 80 characters.
-- See also |localtime()|, |getftime()| and |strptime()|.
-- The language can be changed with the |:language| command.
-- Examples: 
-- ```vim
--   :echo strftime("%c")       Sun Apr 27 11:49:23 1997
--   :echo strftime("%Y %b %d %X")     1997 Apr 27 11:53:25
--   :echo strftime("%y%m%d %T")     970427 11:53:55
--   :echo strftime("%H:%M")     11:55
--   :echo strftime("%c", getftime("file.c"))
--            Show mod time of file.c.
-- 
-- ```
-- Can also be used as a |method|: >
--   GetFormat()->strftime()
--- @param time? any
--- @return string
function vim.fn.strftime(format, time) end

-- Get a Number corresponding to the character at {index} in
-- {str}.  This uses a zero-based character index, not a byte
-- index.  Composing characters are considered separate
-- characters here.  Use |nr2char()| to convert the Number to a
-- String.
-- Returns -1 if {index} is invalid.
-- Also see |strcharpart()| and |strchars()|.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetText()->strgetchar(5)
-- ```
--- @param str string
--- @param index number
--- @return number
function vim.fn.strgetchar(str, index) end

-- The result is a Number, which gives the byte index in
-- {haystack} of the first occurrence of the String {needle}.
-- If {start} is specified, the search starts at index {start}.
-- This can be used to find a second match: 
-- ```vim
--   :let colon1 = stridx(line, ":")
--   :let colon2 = stridx(line, ":", colon1 + 1)
-- ```
-- The search is done case-sensitive.
-- For pattern searches use |match()|.
-- -1 is returned if the {needle} does not occur in {haystack}.
-- See also |strridx()|.
-- Examples: 
-- ```vim
--   :echo stridx("An Example", "Example")       3
--   :echo stridx("Starting point", "Start")    0
--   :echo stridx("Starting point", "start")   -1
-- ```
-- stridx() works similar to the C function strstr().  When used
-- with a single character it works similar to strchr().
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetHaystack()->stridx(needle)
-- ```
--- @param start? number
--- @return number
function vim.fn.stridx(haystack, needle, start) end

-- Return {expr} converted to a String.  If {expr} is a Number,
--   Float, String, Blob or a composition of them, then the result
--   can be parsed back with |eval()|.
--     {expr} type  result ~
--     String    'string'
--     Number    123
--     Float    123.123456 or 1.123456e8 or
--         `str2float('inf')`
--     Funcref    `function('name')`
--     Blob    0z00112233.44556677.8899
--     List    [item, item]
--     Dictionary  {key: value, key: value}
--   Note that in String values the ' character is doubled.
--   Also see |strtrans()|.
--   Note 2: Output format is mostly compatible with YAML, except
--   for infinite and NaN floating-point values representations
--   which use |str2float()|.  Strings are also dumped literally,
--   only single quote is escaped, which does not allow using YAML
--   for parsing back binary strings.  |eval()| should always work for
--   strings and floats though and this is the only official
--   method, use |msgpackdump()| or |json_encode()| if you need to
--   share data with other application.
-- 
--   Can also be used as a |method|: 
-- ```vim
--     mylist->string()
-- ```
--- @return string
function vim.fn.string(expr) end

-- The result is a Number, which is the length of the String
-- {string} in bytes.
-- If the argument is a Number it is first converted to a String.
-- For other types an error is given and zero is returned.
-- If you want to count the number of multibyte characters use
-- |strchars()|.
-- Also see |len()|, |strdisplaywidth()| and |strwidth()|.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetString()->strlen()
-- ```
--- @param string string
--- @return number
function vim.fn.strlen(string) end

-- The result is a String, which is part of {src}, starting from
-- byte {start}, with the byte length {len}.
-- When {chars} is present and TRUE then {len} is the number of
-- characters positions (composing characters are not counted
-- separately, thus "1" means one base character and any
-- following composing characters).
-- To count {start} as characters instead of bytes use
-- |strcharpart()|.
-- 
-- When bytes are selected which do not exist, this doesn't
-- result in an error, the bytes are simply omitted.
-- If {len} is missing, the copy continues from {start} till the
-- end of the {src}. 
-- ```vim
--   strpart("abcdefg", 3, 2)    == "de"
--   strpart("abcdefg", -2, 4)   == "ab"
--   strpart("abcdefg", 5, 4)    == "fg"
--   strpart("abcdefg", 3)      == "defg"
-- 
-- ```
-- Note: To get the first character, {start} must be 0.  For
-- example, to get the character under the cursor: 
-- ```vim
--   strpart(getline("."), col(".") - 1, 1, v:true)
-- ```
-- Returns an empty string on error.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetText()->strpart(5)
-- ```
--- @param start number
--- @param len? any
--- @param chars? any
--- @return string
function vim.fn.strpart(src, start, len, chars) end

-- The result is a Number, which is a unix timestamp representing
-- the date and time in {timestring}, which is expected to match
-- the format specified in {format}.
-- 
-- The accepted {format} depends on your system, thus this is not
-- portable!  See the manual page of the C function strptime()
-- for the format.  Especially avoid "%c".  The value of $TZ also
-- matters.
-- 
-- If the {timestring} cannot be parsed with {format} zero is
-- returned.  If you do not know the format of {timestring} you
-- can try different {format} values until you get a non-zero
-- result.
-- 
-- See also |strftime()|.
-- Examples: 
-- ```vim
--   :echo strptime("%Y %b %d %X", "1997 Apr 27 11:49:23")
-- ```
--   862156163 >
--   :echo strftime("%c", strptime("%y%m%d %T", "970427 11:53:55"))
-- <      Sun Apr 27 11:53:55 1997 
-- ```vim
--   :echo strftime("%c", strptime("%Y%m%d%H%M%S", "19970427115355") + 3600)
-- ```
--   Sun Apr 27 12:53:55 1997
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetFormat()->strptime(timestring)
-- ```
--- @return number
function vim.fn.strptime(format, timestring) end

-- The result is a Number, which gives the byte index in
-- {haystack} of the last occurrence of the String {needle}.
-- When {start} is specified, matches beyond this index are
-- ignored.  This can be used to find a match before a previous
-- match: 
-- ```vim
--   :let lastcomma = strridx(line, ",")
--   :let comma2 = strridx(line, ",", lastcomma - 1)
-- ```
-- The search is done case-sensitive.
-- For pattern searches use |match()|.
-- -1 is returned if the {needle} does not occur in {haystack}.
-- If the {needle} is empty the length of {haystack} is returned.
-- See also |stridx()|.  Examples: 
-- ```vim
--   :echo strridx("an angry armadillo", "an")       3
-- ```
-- When used with a single character it works similar to the C
-- function strrchr().
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetHaystack()->strridx(needle)
-- ```
--- @param start? number
--- @return number
function vim.fn.strridx(haystack, needle, start) end

-- The result is a String, which is {string} with all unprintable
-- characters translated into printable characters |'isprint'|.
-- Like they are shown in a window.  Example: 
-- ```vim
--   echo strtrans(@a)
-- ```
-- This displays a newline in register a as "^@" instead of
-- starting a new line.
-- 
-- Returns an empty string on error.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetString()->strtrans()
-- ```
--- @param string string
--- @return string
function vim.fn.strtrans(string) end

-- The result is a Number, which is the number of UTF-16 code
-- units in String {string} (after converting it to UTF-16).
-- 
-- When {countcc} is TRUE, composing characters are counted
-- separately.
-- When {countcc} is omitted or FALSE, composing characters are
-- ignored.
-- 
-- Returns zero on error.
-- 
-- Also see |strlen()| and |strcharlen()|.
-- Examples: 
-- ```vim
--     echo strutf16len('a')    returns 1
--     echo strutf16len('©')    returns 1
--     echo strutf16len('😊')    returns 2
--     echo strutf16len('ą́')    returns 1
--     echo strutf16len('ą́', v:true)  returns 3
-- 
-- Can also be used as a |method|: >
--   GetText()->strutf16len()
-- ```
--- @param string string
--- @param countcc? any
--- @return number
function vim.fn.strutf16len(string, countcc) end

-- The result is a Number, which is the number of display cells
-- String {string} occupies.  A Tab character is counted as one
-- cell, alternatively use |strdisplaywidth()|.
-- When {string} contains characters with East Asian Width Class
-- Ambiguous, this function's return value depends on 'ambiwidth'.
-- Returns zero on error.
-- Also see |strlen()|, |strdisplaywidth()| and |strchars()|.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetString()->strwidth()
-- ```
--- @param string string
--- @return number
function vim.fn.strwidth(string) end

-- Only for an expression in a |:substitute| command or
-- substitute() function.
-- Returns the {nr}th submatch of the matched text.  When {nr}
-- is 0 the whole matched text is returned.
-- Note that a NL in the string can stand for a line break of a
-- multi-line match or a NUL character in the text.
-- Also see |sub-replace-expression|.
-- 
-- If {list} is present and non-zero then submatch() returns
-- a list of strings, similar to |getline()| with two arguments.
-- NL characters in the text represent NUL characters in the
-- text.
-- Only returns more than one item for |:substitute|, inside
-- |substitute()| this list will always contain one or zero
-- items, since there are no real line breaks.
-- 
-- When substitute() is used recursively only the submatches in
-- the current (deepest) call can be obtained.
-- 
-- Returns an empty string or list on error.
-- 
-- Examples: 
-- ```vim
--   :s/\d\+/\=submatch(0) + 1/
--   :echo substitute(text, '\d\+', '\=submatch(0) + 1', '')
-- ```
-- This finds the first number in the line and adds one to it.
-- A line break is included as a newline character.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetNr()->submatch()
-- ```
--- @param nr number
--- @param list? any[]
--- @return string
function vim.fn.submatch(nr, list) end

-- The result is a String, which is a copy of {string}, in which
-- the first match of {pat} is replaced with {sub}.
-- When {flags} is "g", all matches of {pat} in {string} are
-- replaced.  Otherwise {flags} should be "".
-- 
-- This works like the ":substitute" command (without any flags).
-- But the matching with {pat} is always done like the 'magic'
-- option is set and 'cpoptions' is empty (to make scripts
-- portable).  'ignorecase' is still relevant, use |/\c| or |/\C|
-- if you want to ignore or match case and ignore 'ignorecase'.
-- 'smartcase' is not used.  See |string-match| for how {pat} is
-- used.
-- 
-- A "~" in {sub} is not replaced with the previous {sub}.
-- Note that some codes in {sub} have a special meaning
-- |sub-replace-special|.  For example, to replace something with
-- "\n" (two characters), use "\\\\n" or '\\n'.
-- 
-- When {pat} does not match in {string}, {string} is returned
-- unmodified.
-- 
-- Example: 
-- ```vim
--   :let &path = substitute(&path, ",\\=[^,]*$", "", "")
-- ```
-- This removes the last component of the 'path' option. >
--   :echo substitute("testing", ".*", "\\U\\0", "")
-- <    results in "TESTING".
-- 
-- When {sub} starts with "\=", the remainder is interpreted as
-- an expression. See |sub-replace-expression|.  Example: 
-- ```vim
--   :echo substitute(s, '%\(\x\x\)',
--      \ '\=nr2char("0x" .. submatch(1))', 'g')
-- 
-- ```
-- When {sub} is a Funcref that function is called, with one
-- optional argument.  Example: 
-- ```vim
--    :echo substitute(s, '%\(\x\x\)', SubNr, 'g')
-- ```
-- The optional argument is a list which contains the whole
-- matched string and up to nine submatches, like what
-- |submatch()| returns.  Example: 
-- ```vim
--    :echo substitute(s, '%\(\x\x\)', {m -> '0x' .. m[1]}, 'g')
-- 
-- ```
-- Returns an empty string on error.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetString()->substitute(pat, sub, flags)
-- ```
--- @param string string
--- @return string
function vim.fn.substitute(string, pat, sub, flags) end

-- Returns a list of swap file names, like what "vim -r" shows.
-- See the |-r| command argument.  The 'directory' option is used
-- for the directories to inspect.  If you only want to get a
-- list of swap files in the current directory then temporarily
-- set 'directory' to a dot: 
-- ```vim
--   let save_dir = &directory
--   let &directory = '.'
--   let swapfiles = swapfilelist()
--   let &directory = save_dir
-- ```
--- @return any[]
function vim.fn.swapfilelist() end

-- The result is a dictionary, which holds information about the
-- swapfile {fname}. The available fields are:
--   version Vim version
--   user  user name
--   host  host name
--   fname  original file name
--   pid  PID of the Vim process that created the swap
--     file
--   mtime  last modification time in seconds
--   inode  Optional: INODE number of the file
--   dirty  1 if file was modified, 0 if not
-- In case of failure an "error" item is added with the reason:
--   Cannot open file: file not found or in accessible
--   Cannot read file: cannot read first block
--   Not a swap file: does not contain correct block ID
--   Magic number mismatch: Info in first block is invalid
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetFilename()->swapinfo()
-- ```
--- @return table<string, any>
function vim.fn.swapinfo(fname) end

-- The result is the swap file path of the buffer {buf}.
-- For the use of {buf}, see |bufname()| above.
-- If buffer {buf} is the current buffer, the result is equal to
-- |:swapname| (unless there is no swap file).
-- If buffer {buf} has no swap file, returns an empty string.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetBufname()->swapname()
-- ```
--- @param buf buffer
--- @return string
function vim.fn.swapname(buf) end

-- The result is a Number, which is the syntax ID at the position
-- {lnum} and {col} in the current window.
-- The syntax ID can be used with |synIDattr()| and
-- |synIDtrans()| to obtain syntax information about text.
-- 
-- {col} is 1 for the leftmost column, {lnum} is 1 for the first
-- line.  'synmaxcol' applies, in a longer line zero is returned.
-- Note that when the position is after the last character,
-- that's where the cursor can be in Insert mode, synID() returns
-- zero.  {lnum} is used like with |getline()|.
-- 
-- When {trans} is |TRUE|, transparent items are reduced to the
-- item that they reveal.  This is useful when wanting to know
-- the effective color.  When {trans} is |FALSE|, the transparent
-- item is returned.  This is useful when wanting to know which
-- syntax item is effective (e.g. inside parens).
-- Warning: This function can be very slow.  Best speed is
-- obtained by going through the file in forward direction.
-- 
-- Returns zero on error.
-- 
-- Example (echoes the name of the syntax item under the cursor): 
-- ```vim
--   :echo synIDattr(synID(line("."), col("."), 1), "name")
-- ```
--- @param lnum number
--- @param col number
--- @return number
function vim.fn.synID(lnum, col, trans) end

--   The result is a String, which is the {what} attribute of
--   syntax ID {synID}.  This can be used to obtain information
--   about a syntax item.
--   {mode} can be "gui" or "cterm", to get the attributes
--   for that mode.  When {mode} is omitted, or an invalid value is
--   used, the attributes for the currently active highlighting are
--   used (GUI or cterm).
--   Use synIDtrans() to follow linked highlight groups.
--   {what}    result
--   "name"    the name of the syntax item
--   "fg"    foreground color (GUI: color name used to set
--       the color, cterm: color number as a string,
--       term: empty string)
--   "bg"    background color (as with "fg")
--   "font"    font name (only available in the GUI)
--       |highlight-font|
--   "sp"    special color (as with "fg") |guisp|
--   "fg#"    like "fg", but for the GUI and the GUI is
--       running the name in "#RRGGBB" form
--   "bg#"    like "fg#" for "bg"
--   "sp#"    like "fg#" for "sp"
--   "bold"    "1" if bold
--   "italic"  "1" if italic
--   "reverse"  "1" if reverse
--   "inverse"  "1" if inverse (= reverse)
--   "standout"  "1" if standout
--   "underline"  "1" if underlined
--   "undercurl"  "1" if undercurled
--   "underdouble"  "1" if double underlined
--   "underdotted"  "1" if dotted underlined
--   "underdashed"  "1" if dashed underlined
--   "strikethrough"  "1" if struckthrough
--   "altfont"  "1" if alternative font
--   "nocombine"  "1" if nocombine
-- 
--   Returns an empty string on error.
-- 
--   Example (echoes the color of the syntax item under the
--   cursor): 
-- ```vim
-- :echo synIDattr(synIDtrans(synID(line("."), col("."), 1)), "fg")
-- ```
--   Can also be used as a |method|: 
-- ```vim
-- :echo synID(line("."), col("."), 1)->synIDtrans()->synIDattr("fg")
-- ```
--- @param mode? any
--- @return string
function vim.fn.synIDattr(synID, what, mode) end

--   The result is a Number, which is the translated syntax ID of
--   {synID}.  This is the syntax group ID of what is being used to
--   highlight the character.  Highlight links given with
--   ":highlight link" are followed.
-- 
--   Returns zero on error.
-- 
--   Can also be used as a |method|: 
-- ```vim
-- :echo synID(line("."), col("."), 1)->synIDtrans()->synIDattr("fg")
-- ```
--- @return number
function vim.fn.synIDtrans(synID) end

-- The result is a |List| with currently three items:
-- 1. The first item in the list is 0 if the character at the
--    position {lnum} and {col} is not part of a concealable
--    region, 1 if it is.  {lnum} is used like with |getline()|.
-- 2. The second item in the list is a string. If the first item
--    is 1, the second item contains the text which will be
--    displayed in place of the concealed text, depending on the
--    current setting of 'conceallevel' and 'listchars'.
-- 3. The third and final item in the list is a number
--    representing the specific syntax region matched in the
--    line. When the character is not concealed the value is
--    zero. This allows detection of the beginning of a new
--    concealable region if there are two consecutive regions
--    with the same replacement character.  For an example, if
--    the text is "123456" and both "23" and "45" are concealed
--    and replaced by the character "X", then:
--   call      returns ~
--   synconcealed(lnum, 1)   [0, '', 0]
--   synconcealed(lnum, 2)   [1, 'X', 1]
--   synconcealed(lnum, 3)   [1, 'X', 1]
--   synconcealed(lnum, 4)   [1, 'X', 2]
--   synconcealed(lnum, 5)   [1, 'X', 2]
--   synconcealed(lnum, 6)   [0, '', 0]
--- @param lnum number
--- @param col number
--- @return any[]
function vim.fn.synconcealed(lnum, col) end

-- Return a |List|, which is the stack of syntax items at the
-- position {lnum} and {col} in the current window.  {lnum} is
-- used like with |getline()|.  Each item in the List is an ID
-- like what |synID()| returns.
-- The first item in the List is the outer region, following are
-- items contained in that one.  The last one is what |synID()|
-- returns, unless not the whole item is highlighted or it is a
-- transparent item.
-- This function is useful for debugging a syntax file.
-- Example that shows the syntax stack under the cursor: 
-- ```vim
--   for id in synstack(line("."), col("."))
--      echo synIDattr(id, "name")
--   endfor
-- ```
-- When the position specified with {lnum} and {col} is invalid
-- an empty list is returned.  The position just after the last
-- character in a line and the first column in an empty line are
-- valid positions.
--- @param lnum number
--- @param col number
--- @return any[]
function vim.fn.synstack(lnum, col) end

-- Note: Prefer |vim.system()| in Lua.
-- 
-- Gets the output of {cmd} as a |string| (|systemlist()| returns
-- a |List|) and sets |v:shell_error| to the error code.
-- {cmd} is treated as in |jobstart()|:
-- If {cmd} is a List it runs directly (no 'shell').
-- If {cmd} is a String it runs in the 'shell', like this: 
-- ```vim
--   :call jobstart(split(&shell) + split(&shellcmdflag) + ['{cmd}'])
-- 
-- ```
-- Not to be used for interactive commands.
-- 
-- Result is a String, filtered to avoid platform-specific quirks:
-- - <CR><NL> is replaced with <NL
-- ```vim
-- - NUL characters are replaced with SOH (0x01)
-- 
-- Example: >
--     :echo system(['ls', expand('%:h')])
-- 
-- ```
-- If {input} is a string it is written to a pipe and passed as
-- stdin to the command.  The string is written as-is, line
-- separators are not changed.
-- If {input} is a |List| it is written to the pipe as
-- |writefile()| does with {binary} set to "b" (i.e. with
-- a newline between each list item, and newlines inside list
-- items converted to NULs).
-- When {input} is given and is a valid buffer id, the content of
-- the buffer is written to the file line by line, each line
-- terminated by NL (and NUL where the text has NL).
-- 
-- Note: system() cannot write to or read from backgrounded ("&")
-- shell commands, e.g.: 
-- ```vim
--     :echo system("cat - &", "foo")
-- ```
-- which is equivalent to: >
--     $ echo foo | bash -c 'cat - &'
-- <    The pipes are disconnected (unless overridden by shell
-- redirection syntax) before input can reach it. Use
-- |jobstart()| instead.
-- 
-- Note: Use |shellescape()| or |::S| with |expand()| or
-- |fnamemodify()| to escape special characters in a command
-- argument. 'shellquote' and 'shellxquote' must be properly
-- configured. Example: 
-- ```vim
--     :echo system('ls '..shellescape(expand('%:h')))
--     :echo system('ls '..expand('%:h:S'))
-- 
-- ```
-- Unlike ":!cmd" there is no automatic check for changed files.
-- Use |:checktime| to force a check.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   :echo GetCmd()->system()
-- ```
--- @param input? any
--- @return string
function vim.fn.system(cmd, input) end

-- Same as |system()|, but returns a |List| with lines (parts of
-- output separated by NL) with NULs transformed into NLs. Output
-- is the same as |readfile()| will output with {binary} argument
-- set to "b", except that a final newline is not preserved,
-- unless {keepempty} is non-zero.
-- Note that on MS-Windows you may get trailing CR characters.
-- 
-- To see the difference between "echo hello" and "echo -n hello"
-- use |system()| and |split()|: 
-- ```vim
--   echo split(system('echo hello'), '\n', 1)
-- ```
-- Returns an empty string on error.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   :echo GetCmd()->systemlist()
-- ```
--- @param input? any
--- @param keepempty? any
--- @return any[]
function vim.fn.systemlist(cmd, input, keepempty) end

-- The result is a |List|, where each item is the number of the
-- buffer associated with each window in the current tab page.
-- {arg} specifies the number of the tab page to be used. When
-- omitted the current tab page is used.
-- When {arg} is invalid the number zero is returned.
-- To get a list of all buffers in all tabs use this: 
-- ```vim
--   let buflist = []
--   for i in range(tabpagenr('$'))
--      call extend(buflist, tabpagebuflist(i + 1))
--   endfor
-- ```
-- Note that a buffer may appear in more than one window.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetTabpage()->tabpagebuflist()
-- ```
--- @param arg? any
--- @return any[]
function vim.fn.tabpagebuflist(arg) end

-- The result is a Number, which is the number of the current
-- tab page.  The first tab page has number 1.
-- 
-- The optional argument {arg} supports the following values:
--   $  the number of the last tab page (the tab page
--     count).
--   #  the number of the last accessed tab page
--     (where |g<Tab>| goes to).  If there is no
--     previous tab page, 0 is returned.
-- The number can be used with the |:tab| command.
-- 
-- Returns zero on error.
--- @param arg? any
--- @return number
function vim.fn.tabpagenr(arg) end

-- Like |winnr()| but for tab page {tabarg}.
-- {tabarg} specifies the number of tab page to be used.
-- {arg} is used like with |winnr()|:
-- - When omitted the current window number is returned.  This is
--   the window which will be used when going to this tab page.
-- - When "$" the number of windows is returned.
-- - When "#" the previous window nr is returned.
-- Useful examples: 
-- ```vim
--     tabpagewinnr(1)      " current window of tab page 1
--     tabpagewinnr(4, '$')    " number of windows in tab page 4
-- ```
-- When {tabarg} is invalid zero is returned.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetTabpage()->tabpagewinnr()
-- ```
--- @param arg? any
--- @return number
function vim.fn.tabpagewinnr(tabarg, arg) end

-- Returns a |List| with the file names used to search for tags
--   for the current buffer.  This is the 'tags' option expanded.
--- @return any[]
function vim.fn.tagfiles() end

-- Returns a |List| of tags matching the regular expression {expr}.
-- 
-- If {filename} is passed it is used to prioritize the results
-- in the same way that |:tselect| does. See |tag-priority|.
-- {filename} should be the full path of the file.
-- 
-- Each list item is a dictionary with at least the following
-- entries:
--   name    Name of the tag.
--   filename  Name of the file where the tag is
--       defined.  It is either relative to the
--       current directory or a full path.
--   cmd    Ex command used to locate the tag in
--       the file.
--   kind    Type of the tag.  The value for this
--       entry depends on the language specific
--       kind values.  Only available when
--       using a tags file generated by
--       Universal/Exuberant ctags or hdrtag.
--   static    A file specific tag.  Refer to
--       |static-tag| for more information.
-- More entries may be present, depending on the content of the
-- tags file: access, implementation, inherits and signature.
-- Refer to the ctags documentation for information about these
-- fields.  For C code the fields "struct", "class" and "enum"
-- may appear, they give the name of the entity the tag is
-- contained in.
-- 
-- The ex-command "cmd" can be either an ex search pattern, a
-- line number or a line number followed by a byte number.
-- 
-- If there are no matching tags, then an empty list is returned.
-- 
-- To get an exact tag match, the anchors '^' and '$' should be
-- used in {expr}.  This also make the function work faster.
-- Refer to |tag-regexp| for more information about the tag
-- search regular expression pattern.
-- 
-- Refer to |'tags'| for information about how the tags file is
-- located by Vim. Refer to |tags-file-format| for the format of
-- the tags file generated by the different ctags tools.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetTagpattern()->taglist()
-- ```
--- @param filename? any
--- @return any[]
function vim.fn.taglist(expr, filename) end

-- Return the tangent of {expr}, measured in radians, as a |Float|
-- in the range [-inf, inf].
-- {expr} must evaluate to a |Float| or a |Number|.
-- Returns 0.0 if {expr} is not a |Float| or a |Number|.
-- Examples: 
-- ```vim
--   :echo tan(10)
-- ```
--   0.648361 >
--   :echo tan(-4.01)
-- <      -1.181502
-- 
-- Can also be used as a |method|: 
-- ```vim
--   Compute()->tan()
-- ```
--- @return float
function vim.fn.tan(expr) end

-- Return the hyperbolic tangent of {expr} as a |Float| in the
-- range [-1, 1].
-- {expr} must evaluate to a |Float| or a |Number|.
-- Returns 0.0 if {expr} is not a |Float| or a |Number|.
-- Examples: 
-- ```vim
--   :echo tanh(0.5)
-- ```
--   0.462117 >
--   :echo tanh(-1)
-- <      -0.761594
-- 
-- Can also be used as a |method|: 
-- ```vim
--   Compute()->tanh()
-- ```
--- @return float
function vim.fn.tanh(expr) end

-- Generates a (non-existent) filename located in the Nvim root
-- |tempdir|. Scripts can use the filename as a temporary file.
-- Example: 
-- ```vim
--   :let tmpfile = tempname()
--   :exe "redir > " .. tmpfile
-- ```
--- @return string
function vim.fn.tempname() end

-- Spawns {cmd} in a new pseudo-terminal session connected
-- to the current (unmodified) buffer. Parameters and behavior
-- are the same as |jobstart()| except "pty", "width", "height",
-- and "TERM" are ignored: "height" and "width" are taken from
-- the current window. Note that termopen() implies a "pty" arg
-- to jobstart(), and thus has the implications documented at
-- |jobstart()|.
-- 
-- Returns the same values as jobstart().
-- 
-- Terminal environment is initialized as in |jobstart-env|,
-- except $TERM is set to "xterm-256color". Full behavior is
-- described in |terminal|.
--- @param opts? table<string, any>
function vim.fn.termopen(cmd, opts) end

-- none  free memory right now for testing
function vim.fn.test_garbagecollect_now() end

-- Return a list with information about timers.
-- When {id} is given only information about this timer is
-- returned.  When timer {id} does not exist an empty list is
-- returned.
-- When {id} is omitted information about all timers is returned.
-- 
-- For each timer the information is stored in a |Dictionary| with
-- these items:
--     "id"      the timer ID
--     "time"      time the timer was started with
--     "repeat"      number of times the timer will still fire;
--         -1 means forever
--     "callback"      the callback
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetTimer()->timer_info()
-- ```
--- @param id? any
--- @return any[]
function vim.fn.timer_info(id) end

-- Pause or unpause a timer.  A paused timer does not invoke its
-- callback when its time expires.  Unpausing a timer may cause
-- the callback to be invoked almost immediately if enough time
-- has passed.
-- 
-- Pausing a timer is useful to avoid the callback to be called
-- for a short time.
-- 
-- If {paused} evaluates to a non-zero Number or a non-empty
-- String, then the timer is paused, otherwise it is unpaused.
-- See |non-zero-arg|.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetTimer()->timer_pause(1)
-- ```
function vim.fn.timer_pause(timer, paused) end

-- Create a timer and return the timer ID.
-- 
-- {time} is the waiting time in milliseconds. This is the
-- minimum time before invoking the callback.  When the system is
-- busy or Vim is not waiting for input the time will be longer.
-- Zero can be used to execute the callback when Vim is back in
-- the main loop.
-- 
-- {callback} is the function to call.  It can be the name of a
-- function or a |Funcref|.  It is called with one argument, which
-- is the timer ID.  The callback is only invoked when Vim is
-- waiting for input.
-- 
-- {options} is a dictionary.  Supported entries:
--    "repeat"  Number of times to repeat the callback.
--     -1 means forever.  Default is 1.
--     If the timer causes an error three times in a
--     row the repeat is cancelled.
-- 
-- Returns -1 on error.
-- 
-- Example: 
-- ```vim
--   func MyHandler(timer)
--     echo 'Handler called'
--   endfunc
--   let timer = timer_start(500, 'MyHandler',
--     \ {'repeat': 3})
-- ```
-- This invokes MyHandler() three times at 500 msec intervals.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetMsec()->timer_start(callback)
-- 
-- ```
-- Not available in the |sandbox|.
--- @param callback fun()
--- @param options? table<string, any>
--- @return number
function vim.fn.timer_start(time, callback, options) end

-- Stop a timer.  The timer callback will no longer be invoked.
-- {timer} is an ID returned by timer_start(), thus it must be a
-- Number.  If {timer} does not exist there is no error.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetTimer()->timer_stop()
-- ```
function vim.fn.timer_stop(timer) end

-- Stop all timers.  The timer callbacks will no longer be
-- invoked.  Useful if some timers is misbehaving.  If there are
-- no timers there is no error.
function vim.fn.timer_stopall() end

-- The result is a copy of the String given, with all uppercase
-- characters turned into lowercase (just like applying |gu| to
-- the string).  Returns an empty string on error.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetText()->tolower()
-- ```
--- @return string
function vim.fn.tolower(expr) end

-- The result is a copy of the String given, with all lowercase
-- characters turned into uppercase (just like applying |gU| to
-- the string).  Returns an empty string on error.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetText()->toupper()
-- ```
--- @return string
function vim.fn.toupper(expr) end

-- The result is a copy of the {src} string with all characters
-- which appear in {fromstr} replaced by the character in that
-- position in the {tostr} string.  Thus the first character in
-- {fromstr} is translated into the first character in {tostr}
-- and so on.  Exactly like the unix "tr" command.
-- This code also deals with multibyte characters properly.
-- 
-- Returns an empty string on error.
-- 
-- Examples: 
-- ```vim
--   echo tr("hello there", "ht", "HT")
-- ```
-- returns "Hello THere" >
--   echo tr("<blob>", "<>", "{}")
-- <    returns "{blob}"
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetText()->tr(from, to)
-- ```
--- @return string
function vim.fn.tr(src, fromstr, tostr) end

-- Return {text} as a String where any character in {mask} is
-- removed from the beginning and/or end of {text}.
-- If {mask} is not given, {mask} is all characters up to 0x20,
-- which includes Tab, space, NL and CR, plus the non-breaking
-- space character 0xa0.
-- The optional {dir} argument specifies where to remove the
-- characters:
--   0  remove from the beginning and end of {text}
--   1  remove only at the beginning of {text}
--   2  remove only at the end of {text}
-- When omitted both ends are trimmed.
-- This function deals with multibyte characters properly.
-- Returns an empty string on error.
-- 
-- Examples: 
-- ```vim
--   echo trim("   some text ")
-- ```
-- returns "some text" >
--   echo trim("  \r\t\t\r RESERVE \t\n\x0B\xA0") .. "_TAIL"
-- <    returns "RESERVE_TAIL" 
-- ```vim
--   echo trim("rm<Xrm<>X>rrm", "rm<>")
-- ```
-- returns "Xrm>X" (characters in the middle are not removed) >
--   echo trim("  vim  ", " ", 2)
-- <    returns "  vim"
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetText()->trim()
-- ```
--- @param text string
--- @param mask? any
--- @param dir? any
--- @return string
function vim.fn.trim(text, mask, dir) end

-- Return the largest integral value with magnitude less than or
-- equal to {expr} as a |Float| (truncate towards zero).
-- {expr} must evaluate to a |Float| or a |Number|.
-- Returns 0.0 if {expr} is not a |Float| or a |Number|.
-- Examples: 
-- ```vim
--   echo trunc(1.456)
-- ```
--   1.0  >
--   echo trunc(-5.456)
-- <      -5.0  
-- ```vim
--   echo trunc(4.0)
-- ```
--   4.0
-- 
-- Can also be used as a |method|: 
-- ```vim
--   Compute()->trunc()
-- ```
--- @return float
function vim.fn.trunc(expr) end

-- The result is a Number representing the type of {expr}.
-- Instead of using the number directly, it is better to use the
-- v:t_ variable that has the value:
--         Number:     0 (|v:t_number|)
--   String:     1 (|v:t_string|)
--   Funcref:    2 (|v:t_func|)
--   List:       3 (|v:t_list|)
--   Dictionary: 4 (|v:t_dict|)
--   Float:      5 (|v:t_float|)
--   Boolean:    6 (|v:true| and |v:false|)
--   Null:       7 (|v:null|)
--   Blob:      10 (|v:t_blob|)
-- For backward compatibility, this method can be used: 
-- ```vim
--   :if type(myvar) == type(0)
--   :if type(myvar) == type("")
--   :if type(myvar) == type(function("tr"))
--   :if type(myvar) == type([])
--   :if type(myvar) == type({})
--   :if type(myvar) == type(0.0)
--   :if type(myvar) == type(v:true)
-- ```
-- In place of checking for |v:null| type it is better to check
-- for |v:null| directly as it is the only value of this type: 
-- ```vim
--   :if myvar is v:null
-- ```
--            To check if the v:t_ variables exist use this: >
--                     :if exists('v:t_number')
-- 
-- <    Can also be used as a |method|: 
-- ```vim
--   mylist->type()
-- ```
--- @return number
function vim.fn.type(expr) end

-- Return the name of the undo file that would be used for a file
-- with name {name} when writing.  This uses the 'undodir'
-- option, finding directories that exist.  It does not check if
-- the undo file exists.
-- {name} is always expanded to the full path, since that is what
-- is used internally.
-- If {name} is empty undofile() returns an empty string, since a
-- buffer without a file name will not write an undo file.
-- Useful in combination with |:wundo| and |:rundo|.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetFilename()->undofile()
-- ```
--- @return string
function vim.fn.undofile(name) end

-- Return the current state of the undo tree in a dictionary with
-- the following items:
--   "seq_last"  The highest undo sequence number used.
--   "seq_cur"  The sequence number of the current position in
--     the undo tree.  This differs from "seq_last"
--     when some changes were undone.
--   "time_cur"  Time last used for |:earlier| and related
--     commands.  Use |strftime()| to convert to
--     something readable.
--   "save_last"  Number of the last file write.  Zero when no
--     write yet.
--   "save_cur"  Number of the current position in the undo
--     tree.
--   "synced"  Non-zero when the last undo block was synced.
--     This happens when waiting from input from the
--     user.  See |undo-blocks|.
--   "entries"  A list of dictionaries with information about
--     undo blocks.
-- 
-- The first item in the "entries" list is the oldest undo item.
-- Each List item is a |Dictionary| with these items:
--   "seq"    Undo sequence number.  Same as what appears in
--     |:undolist|.
--   "time"  Timestamp when the change happened.  Use
--     |strftime()| to convert to something readable.
--   "newhead"  Only appears in the item that is the last one
--     that was added.  This marks the last change
--     and where further changes will be added.
--   "curhead"  Only appears in the item that is the last one
--     that was undone.  This marks the current
--     position in the undo tree, the block that will
--     be used by a redo command.  When nothing was
--     undone after the last change this item will
--     not appear anywhere.
--   "save"  Only appears on the last block before a file
--     write.  The number is the write count.  The
--     first write has number 1, the last one the
--     "save_last" mentioned above.
--   "alt"    Alternate entry.  This is again a List of undo
--     blocks.  Each item may again have an "alt"
--     item.
--- @return any[]
function vim.fn.undotree() end

-- Remove second and succeeding copies of repeated adjacent
-- {list} items in-place.  Returns {list}.  If you want a list
-- to remain unmodified make a copy first: 
-- ```vim
--   :let newlist = uniq(copy(mylist))
-- ```
-- The default compare function uses the string representation of
-- each item.  For the use of {func} and {dict} see |sort()|.
-- 
-- Returns zero if {list} is not a |List|.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   mylist->uniq()
-- ```
--- @param list any[]
--- @param func? fun()
--- @param dict? table<string, any>
--- @return any[]
function vim.fn.uniq(list, func, dict) end

-- Same as |charidx()| but returns the UTF-16 code unit index of
-- the byte at {idx} in {string} (after converting it to UTF-16).
-- 
-- When {charidx} is present and TRUE, {idx} is used as the
-- character index in the String {string} instead of as the byte
-- index.
-- An {idx} in the middle of a UTF-8 sequence is rounded
-- downwards to the beginning of that sequence.
-- 
-- Returns -1 if the arguments are invalid or if there are less
-- than {idx} bytes in {string}. If there are exactly {idx} bytes
-- the length of the string in UTF-16 code units is returned.
-- 
-- See |byteidx()| and |byteidxcomp()| for getting the byte index
-- from the UTF-16 index and |charidx()| for getting the
-- character index from the UTF-16 index.
-- Refer to |string-offset-encoding| for more information.
-- Examples: 
-- ```vim
--   echo utf16idx('a😊😊', 3)  returns 2
--   echo utf16idx('a😊😊', 7)  returns 4
--   echo utf16idx('a😊😊', 1, 0, 1)  returns 2
--   echo utf16idx('a😊😊', 2, 0, 1)  returns 4
--   echo utf16idx('aą́c', 6)    returns 2
--   echo utf16idx('aą́c', 6, 1)  returns 4
--   echo utf16idx('a😊😊', 9)  returns -1
-- ```
-- Can also be used as a |method|: 
-- ```vim
--   GetName()->utf16idx(idx)
-- ```
--- @param string string
--- @param countcc? any
--- @param charidx? any
--- @return number
function vim.fn.utf16idx(string, idx, countcc, charidx) end

-- Return a |List| with all the values of {dict}.  The |List| is
-- in arbitrary order.  Also see |items()| and |keys()|.
-- Returns zero if {dict} is not a |Dict|.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   mydict->values()
-- ```
--- @param dict table<string, any>
--- @return any[]
function vim.fn.values(dict) end

-- The result is a Number, which is the screen column of the file
-- position given with {expr}.  That is, the last screen position
-- occupied by the character at that position, when the screen
-- would be of unlimited width.  When there is a <Tab> at the
-- position, the returned Number will be the column at the end of
-- the <Tab>.  For example, for a <Tab> in column 1, with 'ts'
-- set to 8, it returns 8. |conceal| is ignored.
-- For the byte position use |col()|.
-- 
-- For the use of {expr} see |col()|.
-- 
-- When 'virtualedit' is used {expr} can be [lnum, col, off],
-- where "off" is the offset in screen columns from the start of
-- the character.  E.g., a position within a <Tab> or after the
-- last character.  When "off" is omitted zero is used.  When
-- Virtual editing is active in the current mode, a position
-- beyond the end of the line can be returned.  Also see
-- |'virtualedit'|
-- 
-- The accepted positions are:
--     .      the cursor position
--     $      the end of the cursor line (the result is the
--       number of displayed characters in the cursor line
--       plus one)
--     'x      position of mark x (if the mark is not set, 0 is
--       returned)
--     v       In Visual mode: the start of the Visual area (the
--       cursor is the end).  When not in Visual mode
--       returns the cursor position.  Differs from |'<| in
--       that it's updated right away.
-- 
-- If {list} is present and non-zero then virtcol() returns a List
-- with the first and last screen position occupied by the
-- character.
-- 
-- Note that only marks in the current file can be used.
-- Examples: 
-- ```vim
--   " With text "foo^Lbar" and cursor on the "^L":
-- 
--   virtcol(".")  " returns 5
--   virtcol(".", 1)  " returns [4, 5]
--   virtcol("$")  " returns 9
-- 
--   " With text "    there", with 't at 'h':
-- 
--   virtcol("'t")  " returns 6
-- ```
-- The first column is 1.  0 is returned for an error.
-- A more advanced example that echoes the maximum length of
-- all lines: 
-- ```vim
--     echo max(map(range(1, line('$')), "virtcol([v:val, '$'])"))
-- 
-- ```
-- Can also be used as a |method|: >
--   GetPos()->virtcol()
--- @param list? any[]
--- @return number
function vim.fn.virtcol(expr, list) end

-- The result is a Number, which is the byte index of the
-- character in window {winid} at buffer line {lnum} and virtual
-- column {col}.
-- 
-- If {col} is greater than the last virtual column in line
-- {lnum}, then the byte index of the character at the last
-- virtual column is returned.
-- 
-- The {winid} argument can be the window number or the
-- |window-ID|. If this is zero, then the current window is used.
-- 
-- Returns -1 if the window {winid} doesn't exist or the buffer
-- line {lnum} or virtual column {col} is invalid.
-- 
-- See also |screenpos()|, |virtcol()| and |col()|.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetWinid()->virtcol2col(lnum, col)
-- ```
--- @param winid window
--- @param lnum number
--- @param col number
--- @return number
function vim.fn.virtcol2col(winid, lnum, col) end

-- The result is a String, which describes the last Visual mode
-- used in the current buffer.  Initially it returns an empty
-- string, but once Visual mode has been used, it returns "v",
-- "V", or "<CTRL-V>" (a single CTRL-V character) for
-- character-wise, line-wise, or block-wise Visual mode
-- respectively.
-- Example: 
-- ```vim
--   :exe "normal " .. visualmode()
-- ```
-- This enters the same Visual mode as before.  It is also useful
-- in scripts if you wish to act differently depending on the
-- Visual mode that was used.
-- If Visual mode is active, use |mode()| to get the Visual mode
-- (e.g., in a |:vmap|).
-- If {expr} is supplied and it evaluates to a non-zero Number or
-- a non-empty String, then the Visual mode will be cleared and
-- the old value is returned.  See |non-zero-arg|.
--- @param expr? any
--- @return string
function vim.fn.visualmode(expr) end

-- Waits until {condition} evaluates to |TRUE|, where {condition}
-- is a |Funcref| or |string| containing an expression.
-- 
-- {timeout} is the maximum waiting time in milliseconds, -1
-- means forever.
-- 
-- Condition is evaluated on user events, internal events, and
-- every {interval} milliseconds (default: 200).
-- 
-- Returns a status integer:
--   0 if the condition was satisfied before timeout
--   -1 if the timeout was exceeded
--   -2 if the function was interrupted (by |CTRL-C|)
--   -3 if an error occurred
--- @param interval? any
--- @return number
function vim.fn.wait(timeout, condition, interval) end

-- Returns |TRUE| when the wildmenu is active and |FALSE|
-- otherwise.  See 'wildmenu' and 'wildmode'.
-- This can be used in mappings to handle the 'wildcharm' option
-- gracefully. (Makes only sense with |mapmode-c| mappings).
-- 
-- For example to make <c-j> work like <down> in wildmode, use: 
-- ```vim
-- :cnoremap <expr> <C-j> wildmenumode() ? "\<Down>\<Tab>" : "\<c-j>"
-- ```
-- (Note, this needs the 'wildcharm' option set appropriately).
--- @return number
function vim.fn.wildmenumode() end

-- Like `execute()` but in the context of window {id}.
-- The window will temporarily be made the current window,
-- without triggering autocommands or changing directory.  When
-- executing {command} autocommands will be triggered, this may
-- have unexpected side effects.  Use `:noautocmd` if needed.
-- Example: 
-- ```vim
--   call win_execute(winid, 'syntax enable')
-- ```
-- Doing the same with `setwinvar()` would not trigger
-- autocommands and not actually show syntax highlighting.
-- 
-- When window {id} does not exist then no error is given and
-- an empty string is returned.
-- 
-- Can also be used as a |method|, the base is passed as the
-- second argument: 
-- ```vim
--   GetCommand()->win_execute(winid)
-- ```
--- @param silent? any
--- @return string
function vim.fn.win_execute(id, command, silent) end

-- Returns a |List| with |window-ID|s for windows that contain
-- buffer {bufnr}.  When there is none the list is empty.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetBufnr()->win_findbuf()
-- ```
--- @param bufnr buffer
--- @return any[]
function vim.fn.win_findbuf(bufnr) end

-- Get the |window-ID| for the specified window.
-- When {win} is missing use the current window.
-- With {win} this is the window number.  The top window has
-- number 1.
-- Without {tab} use the current tab, otherwise the tab with
-- number {tab}.  The first tab has number one.
-- Return zero if the window cannot be found.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetWinnr()->win_getid()
-- ```
--- @param win? window
--- @param tab? any
--- @return number
function vim.fn.win_getid(win, tab) end

-- Return the type of the window:
--   "autocmd"  autocommand window. Temporary window
--       used to execute autocommands.
--   "command"  command-line window |cmdwin|
--   (empty)    normal window
--   "loclist"  |location-list-window|
--   "popup"    floating window |api-floatwin|
--   "preview"  preview window |preview-window|
--   "quickfix"  |quickfix-window|
--   "unknown"  window {nr} not found
-- 
-- When {nr} is omitted return the type of the current window.
-- When {nr} is given return the type of this window by number or
-- |window-ID|.
-- 
-- Also see the 'buftype' option.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetWinid()->win_gettype()
-- ```
--- @param nr? number
--- @return string
function vim.fn.win_gettype(nr) end

-- Go to window with ID {expr}.  This may also change the current
-- tabpage.
-- Return TRUE if successful, FALSE if the window cannot be found.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetWinid()->win_gotoid()
-- ```
--- @return number
function vim.fn.win_gotoid(expr) end

-- Return a list with the tab number and window number of window
-- with ID {expr}: [tabnr, winnr].
-- Return [0, 0] if the window cannot be found.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetWinid()->win_id2tabwin()
-- ```
--- @return any[]
function vim.fn.win_id2tabwin(expr) end

-- Return the window number of window with ID {expr}.
-- Return 0 if the window cannot be found in the current tabpage.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetWinid()->win_id2win()
-- ```
--- @return number
function vim.fn.win_id2win(expr) end

-- Move window {nr}'s vertical separator (i.e., the right border)
-- by {offset} columns, as if being dragged by the mouse. {nr}
-- can be a window number or |window-ID|. A positive {offset}
-- moves right and a negative {offset} moves left. Moving a
-- window's vertical separator will change the width of the
-- window and the width of other windows adjacent to the vertical
-- separator. The magnitude of movement may be smaller than
-- specified (e.g., as a consequence of maintaining
-- 'winminwidth'). Returns TRUE if the window can be found and
-- FALSE otherwise.
-- This will fail for the rightmost window and a full-width
-- window, since it has no separator on the right.
-- Only works for the current tab page.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetWinnr()->win_move_separator(offset)
-- ```
--- @param nr number
--- @return number
function vim.fn.win_move_separator(nr, offset) end

-- Move window {nr}'s status line (i.e., the bottom border) by
-- {offset} rows, as if being dragged by the mouse. {nr} can be a
-- window number or |window-ID|. A positive {offset} moves down
-- and a negative {offset} moves up. Moving a window's status
-- line will change the height of the window and the height of
-- other windows adjacent to the status line. The magnitude of
-- movement may be smaller than specified (e.g., as a consequence
-- of maintaining 'winminheight'). Returns TRUE if the window can
-- be found and FALSE otherwise.
-- Only works for the current tab page.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetWinnr()->win_move_statusline(offset)
-- ```
--- @param nr number
--- @return number
function vim.fn.win_move_statusline(nr, offset) end

-- Return the screen position of window {nr} as a list with two
-- numbers: [row, col].  The first window always has position
-- [1, 1], unless there is a tabline, then it is [2, 1].
-- {nr} can be the window number or the |window-ID|.  Use zero
-- for the current window.
-- Returns [0, 0] if the window cannot be found in the current
-- tabpage.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetWinid()->win_screenpos()
-- ```
--- @param nr number
--- @return any[]
function vim.fn.win_screenpos(nr) end

-- Move the window {nr} to a new split of the window {target}.
-- This is similar to moving to {target}, creating a new window
-- using |:split| but having the same contents as window {nr}, and
-- then closing {nr}.
-- 
-- Both {nr} and {target} can be window numbers or |window-ID|s.
-- Both must be in the current tab page.
-- 
-- Returns zero for success, non-zero for failure.
-- 
-- {options} is a |Dictionary| with the following optional entries:
--   "vertical"  When TRUE, the split is created vertically,
--     like with |:vsplit|.
--   "rightbelow"  When TRUE, the split is made below or to the
--     right (if vertical).  When FALSE, it is done
--     above or to the left (if vertical).  When not
--     present, the values of 'splitbelow' and
--     'splitright' are used.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetWinid()->win_splitmove(target)
-- ```
--- @param nr number
--- @param options? table<string, any>
--- @return number
function vim.fn.win_splitmove(nr, target, options) end

-- The result is a Number, which is the number of the buffer
--   associated with window {nr}.  {nr} can be the window number or
--   the |window-ID|.
--   When {nr} is zero, the number of the buffer in the current
--   window is returned.
--   When window {nr} doesn't exist, -1 is returned.
--   Example: 
-- ```vim
-- :echo "The file in the current window is " .. bufname(winbufnr(0))
-- ```
--   Can also be used as a |method|: 
-- ```vim
--     FindWindow()->winbufnr()->bufname()
-- ```
--- @param nr number
--- @return number
function vim.fn.winbufnr(nr) end

-- The result is a Number, which is the virtual column of the
--   cursor in the window.  This is counting screen cells from the
--   left side of the window.  The leftmost column is one.
--- @return number
function vim.fn.wincol() end

-- The result is a String.  For MS-Windows it indicates the OS
-- version.  E.g, Windows 10 is "10.0", Windows 8 is "6.2",
-- Windows XP is "5.1".  For non-MS-Windows systems the result is
-- an empty string.
--- @return string
function vim.fn.windowsversion() end

--   The result is a Number, which is the height of window {nr}.
--   {nr} can be the window number or the |window-ID|.
--   When {nr} is zero, the height of the current window is
--   returned.  When window {nr} doesn't exist, -1 is returned.
--   An existing window always has a height of zero or more.
--   This excludes any window toolbar line.
--   Examples: 
-- ```vim
-- :echo "The current window has " .. winheight(0) .. " lines."
-- 
-- ```
--   Can also be used as a |method|: >
--     GetWinid()->winheight()
-- <
--- @param nr number
--- @return number
function vim.fn.winheight(nr) end

-- The result is a nested List containing the layout of windows
-- in a tabpage.
-- 
-- Without {tabnr} use the current tabpage, otherwise the tabpage
-- with number {tabnr}. If the tabpage {tabnr} is not found,
-- returns an empty list.
-- 
-- For a leaf window, it returns:
--   ["leaf", {winid}]
-- For horizontally split windows, which form a column, it
-- returns:
--   ["col", [{nested list of windows}]]
-- For vertically split windows, which form a row, it returns:
--   ["row", [{nested list of windows}]]
-- 
-- Example: 
-- ```vim
--   " Only one window in the tab page
--   :echo winlayout()
--   ['leaf', 1000]
--   " Two horizontally split windows
--   :echo winlayout()
--   ['col', [['leaf', 1000], ['leaf', 1001]]]
--   " The second tab page, with three horizontally split
--   " windows, with two vertically split windows in the
--   " middle window
--   :echo winlayout(2)
--   ['col', [['leaf', 1002], ['row', [['leaf', 1003],
--           ['leaf', 1001]]], ['leaf', 1000]]]
-- ```
-- Can also be used as a |method|: 
-- ```vim
--   GetTabnr()->winlayout()
-- ```
--- @param tabnr? number
--- @return any[]
function vim.fn.winlayout(tabnr) end

-- The result is a Number, which is the screen line of the cursor
--   in the window.  This is counting screen lines from the top of
--   the window.  The first line is one.
--   If the cursor was moved the view on the file will be updated
--   first, this may cause a scroll.
--- @return number
function vim.fn.winline() end

-- The result is a Number, which is the number of the current
--   window.  The top window has number 1.
--   Returns zero for a popup window.
-- 
--   The optional argument {arg} supports the following values:
--     $  the number of the last window (the window
--       count).
--     #  the number of the last accessed window (where
--       |CTRL-W_p| goes to).  If there is no previous
--       window or it is in another tab page 0 is
--       returned.
--     {N}j  the number of the Nth window below the
--       current window (where |CTRL-W_j| goes to).
--     {N}k  the number of the Nth window above the current
--       window (where |CTRL-W_k| goes to).
--     {N}h  the number of the Nth window left of the
--       current window (where |CTRL-W_h| goes to).
--     {N}l  the number of the Nth window right of the
--       current window (where |CTRL-W_l| goes to).
--   The number can be used with |CTRL-W_w| and ":wincmd w"
--   |:wincmd|.
--   When {arg} is invalid an error is given and zero is returned.
--   Also see |tabpagewinnr()| and |win_getid()|.
--   Examples: 
-- ```vim
--     let window_count = winnr('$')
--     let prev_window = winnr('#')
--     let wnum = winnr('3k')
-- 
-- ```
--   Can also be used as a |method|: >
--     GetWinval()->winnr()
-- <
--- @param arg? any
--- @return number
function vim.fn.winnr(arg) end

-- Returns a sequence of |:resize| commands that should restore
--   the current window sizes.  Only works properly when no windows
--   are opened or closed and the current window and tab page is
--   unchanged.
--   Example: 
-- ```vim
--     :let cmd = winrestcmd()
--     :call MessWithWindowSizes()
--     :exe cmd
-- ```
--- @return string
function vim.fn.winrestcmd() end

-- Uses the |Dictionary| returned by |winsaveview()| to restore
-- the view of the current window.
-- Note: The {dict} does not have to contain all values, that are
-- returned by |winsaveview()|. If values are missing, those
-- settings won't be restored. So you can use: 
-- ```vim
--     :call winrestview({'curswant': 4})
-- ```
-- This will only set the curswant value (the column the cursor
-- wants to move on vertical movements) of the cursor to column 5
-- (yes, that is 5), while all other settings will remain the
-- same. This is useful, if you set the cursor position manually.
-- 
-- If you have changed the values the result is unpredictable.
-- If the window size changed the result won't be the same.
-- 
-- Can also be used as a |method|: 
-- ```vim
--   GetView()->winrestview()
-- ```
--- @param dict table<string, any>
function vim.fn.winrestview(dict) end

-- Returns a |Dictionary| that contains information to restore
--   the view of the current window.  Use |winrestview()| to
--   restore the view.
--   This is useful if you have a mapping that jumps around in the
--   buffer and you want to go back to the original view.
--   This does not save fold information.  Use the 'foldenable'
--   option to temporarily switch off folding, so that folds are
--   not opened when moving around. This may have side effects.
--   The return value includes:
--     lnum    cursor line number
--     col    cursor column (Note: the first column
--         zero, as opposed to what |getcurpos()|
--         returns)
--     coladd    cursor column offset for 'virtualedit'
--     curswant  column for vertical movement (Note:
--         the first column is zero, as opposed
--         to what |getcurpos()| returns).  After
--         |$| command it will be a very large
--         number equal to |v:maxcol|.
--     topline    first line in the window
--     topfill    filler lines, only in diff mode
--     leftcol    first column displayed; only used when
--         'wrap' is off
--     skipcol    columns skipped
--   Note that no option values are saved.
--- @return table<string, any>
function vim.fn.winsaveview() end

--   The result is a Number, which is the width of window {nr}.
--   {nr} can be the window number or the |window-ID|.
--   When {nr} is zero, the width of the current window is
--   returned.  When window {nr} doesn't exist, -1 is returned.
--   An existing window always has a width of zero or more.
--   Examples: 
-- ```vim
-- :echo "The current window has " .. winwidth(0) .. " columns."
-- :if winwidth(0) <= 50
-- :  50 wincmd |
-- :endif
-- ```
--   For getting the terminal or screen size, see the 'columns'
--   option.
-- 
--   Can also be used as a |method|: 
-- ```vim
--     GetWinid()->winwidth()
-- ```
--- @param nr number
--- @return number
function vim.fn.winwidth(nr) end

-- The result is a dictionary of byte/chars/word statistics for
-- the current buffer.  This is the same info as provided by
-- |g_CTRL-G|
-- The return value includes:
--   bytes    Number of bytes in the buffer
--   chars    Number of chars in the buffer
--   words    Number of words in the buffer
--   cursor_bytes    Number of bytes before cursor position
--       (not in Visual mode)
--   cursor_chars    Number of chars before cursor position
--       (not in Visual mode)
--   cursor_words    Number of words before cursor position
--       (not in Visual mode)
--   visual_bytes    Number of bytes visually selected
--       (only in Visual mode)
--   visual_chars    Number of chars visually selected
--       (only in Visual mode)
--   visual_words    Number of words visually selected
--       (only in Visual mode)
--- @return table<string, any>
function vim.fn.wordcount() end

-- When {object} is a |List| write it to file {fname}.  Each list
-- item is separated with a NL.  Each list item must be a String
-- or Number.
-- All NL characters are replaced with a NUL character.
-- Inserting CR characters needs to be done before passing {list}
-- to writefile().
-- 
-- When {object} is a |Blob| write the bytes to file {fname}
-- unmodified, also when binary mode is not specified.
-- 
-- {flags} must be a String.  These characters are recognized:
-- 
-- 'b'  Binary mode is used: There will not be a NL after the
--      last list item.  An empty item at the end does cause the
--      last line in the file to end in a NL.
-- 
-- 'a'  Append mode is used, lines are appended to the file: 
-- ```vim
--   :call writefile(["foo"], "event.log", "a")
--   :call writefile(["bar"], "event.log", "a")
-- ```
-- 'D'  Delete the file when the current function ends.  This
--      works like: 
-- ```vim
--   :defer delete({fname})
-- ```
--      Fails when not in a function.  Also see |:defer|.
-- 
-- 's'  fsync() is called after writing the file.  This flushes
--      the file to disk, if possible.  This takes more time but
--      avoids losing the file if the system crashes.
-- 
-- 'S'  fsync() is not called, even when 'fsync' is set.
-- 
--      When {flags} does not contain "S" or "s" then fsync() is
--      called if the 'fsync' option is set.
-- 
-- An existing file is overwritten, if possible.
-- 
-- When the write fails -1 is returned, otherwise 0.  There is an
-- error message if the file can't be created or when writing
-- fails.
-- 
-- Also see |readfile()|.
-- To copy a file byte for byte: 
-- ```vim
--   :let fl = readfile("foo", "b")
--   :call writefile(fl, "foocopy", "b")
-- 
-- ```
-- Can also be used as a |method|: >
--   GetText()->writefile("thefile")
--- @param flags? any
--- @return number
function vim.fn.writefile(object, fname, flags) end

-- Bitwise XOR on the two arguments.  The arguments are converted
-- to a number.  A List, Dict or Float argument causes an error.
-- Also see `and()` and `or()`.
-- Example: 
-- ```vim
--   :let bits = xor(bits, 0x80)
-- ```
-- Can also be used as a |method|: 
-- ```vim
--   :let bits = bits->xor(0x80)
-- ```
--- @return number
function vim.fn.xor(expr, expr1) end

