Neovim Lua API Reference

# Neovim Lua API Reference

This document contains type stubs and API references for Neovim's Lua API.
Use this as a reference when writing Neovim plugins or configurations in Lua.

---

## api

The following are type stubs for all the functions available on `vim.api.*`. Prefer these functions where possible.

```lua
vim.api = {}
vim.api.nvim__buf_debug_extmarks(buffer, keys, dot) 
vim.api.nvim__buf_stats(buffer) 
vim.api.nvim__complete_set(index, opts) 
vim.api.nvim__get_lib_dir() 
vim.api.nvim__get_runtime(pat, all, opts) 
vim.api.nvim__id(obj) 
vim.api.nvim__id_array(arr) 
vim.api.nvim__id_dict(dct) 
vim.api.nvim__id_float(flt) 
vim.api.nvim__inspect_cell(grid, row, col) 
vim.api.nvim__invalidate_glyph_cache() 
vim.api.nvim__ns_get(ns_id) 
vim.api.nvim__ns_set(ns_id, opts) 
vim.api.nvim__redraw(opts) 
vim.api.nvim__runtime_inspect() 
vim.api.nvim__screenshot(path) 
vim.api.nvim__stats() 
vim.api.nvim__unpack(str) 
vim.api.nvim_buf_add_highlight(buffer, ns_id, hl_group, line, col_start, col_end) 
vim.api.nvim_buf_attach(buffer, send_buffer, opts) 
vim.api.nvim_buf_call(buffer, fun) 
vim.api.nvim_buf_clear_highlight(buffer, ns_id, line_start, line_end) 
vim.api.nvim_buf_clear_namespace(buffer, ns_id, line_start, line_end) 
vim.api.nvim_buf_create_user_command(buffer, name, command, opts) 
vim.api.nvim_buf_del_extmark(buffer, ns_id, id) 
vim.api.nvim_buf_del_keymap(buffer, mode, lhs) 
vim.api.nvim_buf_del_mark(buffer, name) 
vim.api.nvim_buf_del_user_command(buffer, name) 
vim.api.nvim_buf_del_var(buffer, name) 
vim.api.nvim_buf_delete(buffer, opts) 
vim.api.nvim_buf_get_changedtick(buffer) 
vim.api.nvim_buf_get_commands(buffer, opts) 
vim.api.nvim_buf_get_extmark_by_id(buffer, ns_id, id, opts) 
vim.api.nvim_buf_get_extmarks(buffer, ns_id, start, end_, opts) 
vim.api.nvim_buf_get_keymap(buffer, mode) 
vim.api.nvim_buf_get_lines(buffer, start, end_, strict_indexing) 
vim.api.nvim_buf_get_mark(buffer, name) 
vim.api.nvim_buf_get_name(buffer) 
vim.api.nvim_buf_get_number(buffer) 
vim.api.nvim_buf_get_offset(buffer, index) 
vim.api.nvim_buf_get_option(buffer, name) 
vim.api.nvim_buf_get_text(buffer, start_row, start_col, end_row, end_col, opts) 
vim.api.nvim_buf_get_var(buffer, name) 
vim.api.nvim_buf_is_loaded(buffer) 
vim.api.nvim_buf_is_valid(buffer) 
vim.api.nvim_buf_line_count(buffer) 
vim.api.nvim_buf_set_extmark(buffer, ns_id, line, col, opts) 
vim.api.nvim_buf_set_keymap(buffer, mode, lhs, rhs, opts) 
vim.api.nvim_buf_set_lines(buffer, start, end_, strict_indexing, replacement) 
vim.api.nvim_buf_set_mark(buffer, name, line, col, opts) 
vim.api.nvim_buf_set_name(buffer, name) 
vim.api.nvim_buf_set_option(buffer, name, value) 
vim.api.nvim_buf_set_text(buffer, start_row, start_col, end_row, end_col, replacement) 
vim.api.nvim_buf_set_var(buffer, name, value) 
vim.api.nvim_buf_set_virtual_text(buffer, src_id, line, chunks, opts) 
vim.api.nvim_call_dict_function(dict, fn, args) 
vim.api.nvim_call_function(fn, args) 
vim.api.nvim_chan_send(chan, data) 
vim.api.nvim_clear_autocmds(opts) 
vim.api.nvim_cmd(cmd, opts) 
vim.api.nvim_command(command) 
vim.api.nvim_command_output(command) 
vim.api.nvim_create_augroup(name, opts) 
vim.api.nvim_create_autocmd(event, opts) 
vim.api.nvim_create_buf(listed, scratch) 
vim.api.nvim_create_namespace(name) 
vim.api.nvim_create_user_command(name, command, opts) 
vim.api.nvim_del_augroup_by_id(id) 
vim.api.nvim_del_augroup_by_name(name) 
vim.api.nvim_del_autocmd(id) 
vim.api.nvim_del_current_line() 
vim.api.nvim_del_keymap(mode, lhs) 
vim.api.nvim_del_mark(name) 
vim.api.nvim_del_user_command(name) 
vim.api.nvim_del_var(name) 
vim.api.nvim_echo(chunks, history, opts) 
vim.api.nvim_err_write(str) 
vim.api.nvim_err_writeln(str) 
vim.api.nvim_eval(expr) 
vim.api.nvim_eval_statusline(str, opts) 
vim.api.nvim_exec(src, output) 
vim.api.nvim_exec2(src, opts) 
vim.api.nvim_exec_autocmds(event, opts) 
vim.api.nvim_feedkeys(keys, mode, escape_ks) 
vim.api.nvim_get_all_options_info() 
vim.api.nvim_get_autocmds(opts) 
vim.api.nvim_get_chan_info(chan) 
vim.api.nvim_get_color_by_name(name) 
vim.api.nvim_get_color_map() 
vim.api.nvim_get_commands(opts) 
vim.api.nvim_get_context(opts) 
vim.api.nvim_get_current_buf() 
vim.api.nvim_get_current_line() 
vim.api.nvim_get_current_tabpage() 
vim.api.nvim_get_current_win() 
vim.api.nvim_get_hl(ns_id, opts) 
vim.api.nvim_get_hl_by_id(hl_id, rgb) 
vim.api.nvim_get_hl_by_name(name, rgb) 
vim.api.nvim_get_hl_id_by_name(name) 
vim.api.nvim_get_hl_ns(opts) 
vim.api.nvim_get_keymap(mode) 
vim.api.nvim_get_mark(name, opts) 
vim.api.nvim_get_mode() 
vim.api.nvim_get_namespaces() 
vim.api.nvim_get_option(name) 
vim.api.nvim_get_option_info(name) 
vim.api.nvim_get_option_info2(name, opts) 
vim.api.nvim_get_option_value(name, opts) 
vim.api.nvim_get_proc(pid) 
vim.api.nvim_get_proc_children(pid) 
vim.api.nvim_get_runtime_file(name, all) 
vim.api.nvim_get_var(name) 
vim.api.nvim_get_vvar(name) 
vim.api.nvim_input(keys) 
vim.api.nvim_input_mouse(button, action, modifier, grid, row, col) 
vim.api.nvim_list_bufs() 
vim.api.nvim_list_chans() 
vim.api.nvim_list_runtime_paths() 
vim.api.nvim_list_tabpages() 
vim.api.nvim_list_uis() 
vim.api.nvim_list_wins() 
vim.api.nvim_load_context(dict) 
vim.api.nvim_notify(msg, log_level, opts) 
vim.api.nvim_open_term(buffer, opts) 
vim.api.nvim_open_win(buffer, enter, config) 
vim.api.nvim_out_write(str) 
vim.api.nvim_parse_cmd(str, opts) 
vim.api.nvim_parse_expression(expr, flags, highlight) 
vim.api.nvim_paste(data, crlf, phase) 
vim.api.nvim_put(lines, type, after, follow) 
vim.api.nvim_replace_termcodes(str, from_part, do_lt, special) 
vim.api.nvim_select_popupmenu_item(item, insert, finish, opts) 
vim.api.nvim_set_current_buf(buffer) 
vim.api.nvim_set_current_dir(dir) 
vim.api.nvim_set_current_line(line) 
vim.api.nvim_set_current_tabpage(tabpage) 
vim.api.nvim_set_current_win(window) 
vim.api.nvim_set_decoration_provider(ns_id, opts) 
vim.api.nvim_set_hl(ns_id, name, val) 
vim.api.nvim_set_hl_ns(ns_id) 
vim.api.nvim_set_hl_ns_fast(ns_id) 
vim.api.nvim_set_keymap(mode, lhs, rhs, opts) 
vim.api.nvim_set_option(name, value) 
vim.api.nvim_set_option_value(name, value, opts) 
vim.api.nvim_set_var(name, value) 
vim.api.nvim_set_vvar(name, value) 
vim.api.nvim_strwidth(text) 
vim.api.nvim_tabpage_del_var(tabpage, name) 
vim.api.nvim_tabpage_get_number(tabpage) 
vim.api.nvim_tabpage_get_var(tabpage, name) 
vim.api.nvim_tabpage_get_win(tabpage) 
vim.api.nvim_tabpage_is_valid(tabpage) 
vim.api.nvim_tabpage_list_wins(tabpage) 
vim.api.nvim_tabpage_set_var(tabpage, name, value) 
vim.api.nvim_tabpage_set_win(tabpage, win) 
vim.api.nvim_win_call(window, fun) 
vim.api.nvim_win_close(window, force) 
vim.api.nvim_win_del_var(window, name) 
vim.api.nvim_win_get_buf(window) 
vim.api.nvim_win_get_config(window) 
vim.api.nvim_win_get_cursor(window) 
vim.api.nvim_win_get_height(window) 
vim.api.nvim_win_get_number(window) 
vim.api.nvim_win_get_option(window, name) 
vim.api.nvim_win_get_position(window) 
vim.api.nvim_win_get_tabpage(window) 
vim.api.nvim_win_get_var(window, name) 
vim.api.nvim_win_get_width(window) 
vim.api.nvim_win_hide(window) 
vim.api.nvim_win_is_valid(window) 
vim.api.nvim_win_set_buf(window, buffer) 
vim.api.nvim_win_set_config(window, config) 
vim.api.nvim_win_set_cursor(window, pos) 
vim.api.nvim_win_set_height(window, height) 
vim.api.nvim_win_set_hl_ns(window, ns_id) 
vim.api.nvim_win_set_option(window, name, value) 
vim.api.nvim_win_set_var(window, name, value) 
vim.api.nvim_win_set_width(window, width) 
vim.api.nvim_win_text_height(window, opts) 
```

---

## builtin

Various APIs that are provided by Neovim, that are unique to the Lua API.

```lua
vim.NIL = ...
function vim.in_fast_event() end
function vim.empty_dict() end
function vim.rpcnotify(channel, method, ...) end
function vim.rpcrequest(channel, method, ...) end
function vim.stricmp(a, b) end
function vim.str_utf_pos(str) end
function vim.str_utf_start(str, index) end
function vim.str_utf_end(str, index) end
function vim.iconv(str, from, to, opts) end
function vim.schedule(fn) end
function vim.wait(time, callback, interval, fast_only) end
function vim.ui_attach(ns, options, callback) end
function vim.ui_detach(ns) end
```

---

## api_keysets

The following describe various types that are used in Neovim's API.

```lua

```

---

## api_keysets_extra

Additional types that are used in Neovim's API.

```lua

```

---

## builtin_types

Various types used by Neovim's builtin APIs.

```lua

```

---

## vimfn

Functions available from Neovim's vimscript APIs. They are available via `vim.fn.*`.

```lua
vim.fn.abs(expr) 
vim.fn.acos(expr) 
vim.fn.add(object, expr) 
vim.fn['and'] = function(expr, expr1) 
vim.fn.api_info() 
vim.fn.append(lnum, text) 
vim.fn.appendbufline(buf, lnum, text) 
vim.fn.argc(winid) 
vim.fn.argidx() 
vim.fn.arglistid(winnr, tabnr) 
vim.fn.argv(nr, winid) 
vim.fn.asin(expr) 
vim.fn.assert_beeps(cmd) 
vim.fn.assert_equal(expected, actual, msg) 
vim.fn.assert_equalfile(fname_one, fname_two) 
vim.fn.assert_exception(error, msg) 
vim.fn.assert_fails(cmd, error, msg, lnum, context) 
vim.fn.assert_false(actual, msg) 
vim.fn.assert_inrange(lower, upper, actual, msg) 
vim.fn.assert_match(pattern, actual, msg) 
vim.fn.assert_nobeep(cmd) 
vim.fn.assert_notequal(expected, actual, msg) 
vim.fn.assert_notmatch(pattern, actual, msg) 
vim.fn.assert_report(msg) 
vim.fn.assert_true(actual, msg) 
vim.fn.atan(expr) 
vim.fn.atan2(expr1, expr2) 
vim.fn.blob2list(blob) 
vim.fn.browse(save, title, initdir, default) 
vim.fn.browsedir(title, initdir) 
vim.fn.bufadd(name) 
vim.fn.bufexists(buf) 
vim.fn.buffer_exists(...) 
vim.fn.buffer_name(...) 
vim.fn.buffer_number(...) 
vim.fn.buflisted(buf) 
vim.fn.bufload(buf) 
vim.fn.bufloaded(buf) 
vim.fn.bufname(buf) 
vim.fn.bufnr(buf, create) 
vim.fn.bufwinid(buf) 
vim.fn.bufwinnr(buf) 
vim.fn.byte2line(byte) 
vim.fn.byteidx(expr, nr, utf16) 
vim.fn.byteidxcomp(expr, nr, utf16) 
vim.fn.call(func, arglist, dict) 
vim.fn.ceil(expr) 
vim.fn.chanclose(id, stream) 
vim.fn.changenr() 
vim.fn.chansend(id, data) 
vim.fn.char2nr(string, utf8) 
vim.fn.charclass(string) 
vim.fn.charcol(expr, winid) 
vim.fn.charidx(string, idx, countcc, utf16) 
vim.fn.chdir(dir) 
vim.fn.cindent(lnum) 
vim.fn.clearmatches(win) 
vim.fn.col(expr, winid) 
vim.fn.complete(startcol, matches) 
vim.fn.complete_add(expr) 
vim.fn.complete_check() 
vim.fn.complete_info(what) 
vim.fn.confirm(msg, choices, default, type) 
vim.fn.copy(expr) 
vim.fn.cos(expr) 
vim.fn.cosh(expr) 
vim.fn.count(comp, expr, ic, start) 
vim.fn.ctxget(index) 
vim.fn.ctxpop() 
vim.fn.ctxpush(types) 
vim.fn.ctxset(context, index) 
vim.fn.ctxsize() 
vim.fn.cursor(lnum, col, off) 
vim.fn.cursor(list) 
vim.fn.debugbreak(pid) 
vim.fn.deepcopy(expr, noref) 
vim.fn.delete(fname, flags) 
vim.fn.deletebufline(buf, first, last) 
vim.fn.dictwatcheradd(dict, pattern, callback) 
vim.fn.dictwatcherdel(dict, pattern, callback) 
vim.fn.did_filetype() 
vim.fn.diff_filler(lnum) 
vim.fn.diff_hlID(lnum, col) 
vim.fn.digraph_get(chars) 
vim.fn.digraph_getlist(listall) 
vim.fn.digraph_set(chars, digraph) 
vim.fn.digraph_setlist(digraphlist) 
vim.fn.empty(expr) 
vim.fn.environ() 
vim.fn.escape(string, chars) 
vim.fn.eval(string) 
vim.fn.eventhandler() 
vim.fn.executable(expr) 
vim.fn.execute(command, silent) 
vim.fn.exepath(expr) 
vim.fn.exists(expr) 
vim.fn.exp(expr) 
vim.fn.expand(string, nosuf, list) 
vim.fn.expand(string, nosuf, list) 
vim.fn.expandcmd(string, options) 
vim.fn.extend(expr1, expr2, expr3) 
vim.fn.extendnew(expr1, expr2, expr3) 
vim.fn.feedkeys(string, mode) 
vim.fn.file_readable(file) 
vim.fn.filecopy(from, to) 
vim.fn.filereadable(file) 
vim.fn.filewritable(file) 
vim.fn.filter(expr1, expr2) 
vim.fn.finddir(name, path, count) 
vim.fn.findfile(name, path, count) 
vim.fn.flatten(list, maxdepth) 
vim.fn.flattennew(list, maxdepth) 
vim.fn.float2nr(expr) 
vim.fn.floor(expr) 
vim.fn.fmod(expr1, expr2) 
vim.fn.fnameescape(string) 
vim.fn.fnamemodify(fname, mods) 
vim.fn.foldclosed(lnum) 
vim.fn.foldclosedend(lnum) 
vim.fn.foldlevel(lnum) 
vim.fn.foldtext() 
vim.fn.foldtextresult(lnum) 
vim.fn.foreach(expr1, expr2) 
vim.fn.fullcommand(name) 
vim.fn.funcref(name, arglist, dict) 
vim.fn['function'] = function(name, arglist, dict) 
vim.fn.garbagecollect(atexit) 
vim.fn.get(list, idx, default) 
vim.fn.get(blob, idx, default) 
vim.fn.get(dict, key, default) 
vim.fn.get(func, what) 
vim.fn.getbufinfo(buf) 
vim.fn.getbufinfo(dict) 
vim.fn.getbufline(buf, lnum, end_) 
vim.fn.getbufoneline(buf, lnum) 
vim.fn.getbufvar(buf, varname, def) 
vim.fn.getcellwidths() 
vim.fn.getchangelist(buf) 
vim.fn.getchar(expr, opts) 
vim.fn.getcharmod() 
vim.fn.getcharpos(expr) 
vim.fn.getcharsearch() 
vim.fn.getcharstr(expr, opts) 
vim.fn.getcmdcomplpat() 
vim.fn.getcmdcompltype() 
vim.fn.getcmdline() 
vim.fn.getcmdpos() 
vim.fn.getcmdprompt() 
vim.fn.getcmdscreenpos() 
vim.fn.getcmdtype() 
vim.fn.getcmdwintype() 
vim.fn.getcompletion(pat, type, filtered) 
vim.fn.getcurpos(winid) 
vim.fn.getcursorcharpos(winid) 
vim.fn.getcwd(winnr, tabnr) 
vim.fn.getenv(name) 
vim.fn.getfontname(name) 
vim.fn.getfperm(fname) 
vim.fn.getfsize(fname) 
vim.fn.getftime(fname) 
vim.fn.getftype(fname) 
vim.fn.getjumplist(winnr, tabnr) 
vim.fn.getline(lnum, end_) 
vim.fn.getline(lnum, end_) 
vim.fn.getloclist(nr, what) 
vim.fn.getmarklist(buf) 
vim.fn.getmatches(win) 
vim.fn.getmousepos() 
vim.fn.getpid() 
vim.fn.getpos(expr) 
vim.fn.getqflist(what) 
vim.fn.getreg(regname, list) 
vim.fn.getreg(regname, list) 
vim.fn.getreginfo(regname) 
vim.fn.getregion(pos1, pos2, opts) 
vim.fn.getregionpos(pos1, pos2, opts) 
vim.fn.getregtype(regname) 
vim.fn.getscriptinfo(opts) 
vim.fn.getstacktrace() 
vim.fn.gettabinfo(tabnr) 
vim.fn.gettabvar(tabnr, varname, def) 
vim.fn.gettabwinvar(tabnr, winnr, varname, def) 
vim.fn.gettagstack(winnr) 
vim.fn.gettext(text) 
vim.fn.getwininfo(winid) 
vim.fn.getwinpos(timeout) 
vim.fn.getwinposx() 
vim.fn.getwinposy() 
vim.fn.getwinvar(winnr, varname, def) 
vim.fn.glob(expr, nosuf, list, alllinks) 
vim.fn.glob2regpat(string) 
vim.fn.globpath(path, expr, nosuf, list, allinks) 
vim.fn.has(feature) 
vim.fn.has_key(dict, key) 
vim.fn.haslocaldir(winnr, tabnr) 
vim.fn.hasmapto(what, mode, abbr) 
vim.fn.highlightID(name) 
vim.fn.highlight_exists(name) 
vim.fn.histadd(history, item) 
vim.fn.histdel(history, item) 
vim.fn.histget(history, index) 
vim.fn.histnr(history) 
vim.fn.hlID(name) 
vim.fn.hlexists(name) 
vim.fn.hostname() 
vim.fn.iconv(string, from, to) 
vim.fn.id(expr) 
vim.fn.indent(lnum) 
vim.fn.index(object, expr, start, ic) 
vim.fn.indexof(object, expr, opts) 
vim.fn.input(prompt, text, completion) 
vim.fn.input(opts) 
vim.fn.inputdialog(...) 
vim.fn.inputlist(textlist) 
vim.fn.inputrestore() 
vim.fn.inputsave() 
vim.fn.inputsecret(prompt, text) 
vim.fn.insert(object, item, idx) 
vim.fn.interrupt() 
vim.fn.invert(expr) 
vim.fn.isabsolutepath(path) 
vim.fn.isdirectory(directory) 
vim.fn.isinf(expr) 
vim.fn.islocked(expr) 
vim.fn.isnan(expr) 
vim.fn.items(dict) 
vim.fn.jobclose(...) 
vim.fn.jobpid(job) 
vim.fn.jobresize(job, width, height) 
vim.fn.jobsend(...) 
vim.fn.jobstart(cmd, opts) 
vim.fn.jobstop(id) 
vim.fn.jobwait(jobs, timeout) 
vim.fn.join(list, sep) 
vim.fn.json_decode(expr) 
vim.fn.json_encode(expr) 
vim.fn.keys(dict) 
vim.fn.keytrans(string) 
vim.fn.last_buffer_nr() 
vim.fn.len(expr) 
vim.fn.libcall(libname, funcname, argument) 
vim.fn.libcallnr(libname, funcname, argument) 
vim.fn.line(expr, winid) 
vim.fn.line2byte(lnum) 
vim.fn.lispindent(lnum) 
vim.fn.list2blob(list) 
vim.fn.list2str(list, utf8) 
vim.fn.localtime() 
vim.fn.log(expr) 
vim.fn.log10(expr) 
vim.fn.map(expr1, expr2) 
vim.fn.maparg(name, mode, abbr, dict) 
vim.fn.maparg(name, mode, abbr, dict) 
vim.fn.mapcheck(name, mode, abbr) 
vim.fn.maplist(abbr) 
vim.fn.mapnew(expr1, expr2) 
vim.fn.mapset(mode, abbr, dict) 
vim.fn.mapset(dict) 
vim.fn.match(expr, pat, start, count) 
vim.fn.matchadd(group, pattern, priority, id, dict) 
vim.fn.matchaddpos(group, pos, priority, id, dict) 
vim.fn.matcharg(nr) 
vim.fn.matchbufline(buf, pat, lnum, end_, dict) 
vim.fn.matchdelete(id, win) 
vim.fn.matchend(expr, pat, start, count) 
vim.fn.matchfuzzy(list, str, dict) 
vim.fn.matchfuzzypos(list, str, dict) 
vim.fn.matchlist(expr, pat, start, count) 
vim.fn.matchstr(expr, pat, start, count) 
vim.fn.matchstrlist(list, pat, dict) 
vim.fn.matchstrpos(expr, pat, start, count) 
vim.fn.max(expr) 
vim.fn.menu_get(path, modes) 
vim.fn.menu_info(name, mode) 
vim.fn.min(expr) 
vim.fn.mkdir(name, flags, prot) 
vim.fn.mode(expr) 
vim.fn.msgpackdump(list, type) 
vim.fn.msgpackparse(data) 
vim.fn.nextnonblank(lnum) 
vim.fn.nr2char(expr, utf8) 
vim.fn['or'] = function(expr, expr1) 
vim.fn.pathshorten(path, len) 
vim.fn.perleval(expr) 
vim.fn.pow(x, y) 
vim.fn.prevnonblank(lnum) 
vim.fn.printf(fmt, expr1) 
vim.fn.prompt_getprompt(buf) 
vim.fn.prompt_setcallback(buf, expr) 
vim.fn.prompt_setinterrupt(buf, expr) 
vim.fn.prompt_setprompt(buf, text) 
vim.fn.pum_getpos() 
vim.fn.pumvisible() 
vim.fn.py3eval(expr) 
vim.fn.pyeval(expr) 
vim.fn.pyxeval(expr) 
vim.fn.rand(expr) 
vim.fn.range(expr, max, stride) 
vim.fn.readblob(fname, offset, size) 
vim.fn.readdir(directory, expr) 
vim.fn.readfile(fname, type, max) 
vim.fn.reduce(object, func, initial) 
vim.fn.reg_executing() 
vim.fn.reg_recorded() 
vim.fn.reg_recording() 
vim.fn.reltime() 
vim.fn.reltime(start) 
vim.fn.reltime(start, end_) 
vim.fn.reltimefloat(time) 
vim.fn.reltimestr(time) 
vim.fn.remove(list, idx) 
vim.fn.remove(list, idx, end_) 
vim.fn.remove(blob, idx) 
vim.fn.remove(blob, idx, end_) 
vim.fn.remove(dict, key) 
vim.fn.rename(from, to) 
vim.fn['repeat'] = function(expr, count) 
vim.fn.resolve(filename) 
vim.fn.reverse(object) 
vim.fn.round(expr) 
vim.fn.rpcnotify(channel, event, ...) 
vim.fn.rpcrequest(channel, method, ...) 
vim.fn.rpcstart(prog, argv) 
vim.fn.rpcstop(...) 
vim.fn.rubyeval(expr) 
vim.fn.screenattr(row, col) 
vim.fn.screenchar(row, col) 
vim.fn.screenchars(row, col) 
vim.fn.screencol() 
vim.fn.screenpos(winid, lnum, col) 
vim.fn.screenrow() 
vim.fn.screenstring(row, col) 
vim.fn.search(pattern, flags, stopline, timeout, skip) 
vim.fn.searchcount(options) 
vim.fn.searchdecl(name, global, thisblock) 
vim.fn.searchpair(start, middle, end_, flags, skip, stopline, timeout) 
vim.fn.searchpairpos(start, middle, end_, flags, skip, stopline, timeout) 
vim.fn.searchpos(pattern, flags, stopline, timeout, skip) 
vim.fn.serverlist() 
vim.fn.serverstart(address) 
vim.fn.serverstop(address) 
vim.fn.setbufline(buf, lnum, text) 
vim.fn.setbufvar(buf, varname, val) 
vim.fn.setcellwidths(list) 
vim.fn.setcharpos(expr, list) 
vim.fn.setcharsearch(dict) 
vim.fn.setcmdline(str, pos) 
vim.fn.setcmdpos(pos) 
vim.fn.setcursorcharpos(lnum, col, off) 
vim.fn.setcursorcharpos(list) 
vim.fn.setenv(name, val) 
vim.fn.setfperm(fname, mode) 
vim.fn.setline(lnum, text) 
vim.fn.setloclist(nr, list, action, what) 
vim.fn.setmatches(list, win) 
vim.fn.setpos(expr, list) 
vim.fn.setqflist(list, action, what) 
vim.fn.setreg(regname, value, options) 
vim.fn.settabvar(tabnr, varname, val) 
vim.fn.settabwinvar(tabnr, winnr, varname, val) 
vim.fn.settagstack(nr, dict, action) 
vim.fn.setwinvar(nr, varname, val) 
vim.fn.sha256(string) 
vim.fn.shellescape(string, special) 
vim.fn.shiftwidth(col) 
vim.fn.sign_define(name, dict) 
vim.fn.sign_define(list) 
vim.fn.sign_getdefined(name) 
vim.fn.sign_getplaced(buf, dict) 
vim.fn.sign_jump(id, group, buf) 
vim.fn.sign_place(id, group, name, buf, dict) 
vim.fn.sign_placelist(list) 
vim.fn.sign_undefine(name) 
vim.fn.sign_undefine(list) 
vim.fn.sign_unplace(group, dict) 
vim.fn.sign_unplacelist(list) 
vim.fn.simplify(filename) 
vim.fn.sin(expr) 
vim.fn.sinh(expr) 
vim.fn.slice(expr, start, end_) 
vim.fn.sockconnect(mode, address, opts) 
vim.fn.sort(list, how, dict) 
vim.fn.soundfold(word) 
vim.fn.spellbadword(sentence) 
vim.fn.spellsuggest(word, max, capital) 
vim.fn.split(string, pattern, keepempty) 
vim.fn.sqrt(expr) 
vim.fn.srand(expr) 
vim.fn.state(what) 
vim.fn.stdioopen(opts) 
vim.fn.stdpath(what) 
vim.fn.stdpath(what) 
vim.fn.stdpath(what) 
vim.fn.str2float(string, quoted) 
vim.fn.str2list(string, utf8) 
vim.fn.str2nr(string, base) 
vim.fn.strcharlen(string) 
vim.fn.strcharpart(src, start, len, skipcc) 
vim.fn.strchars(string, skipcc) 
vim.fn.strdisplaywidth(string, col) 
vim.fn.strftime(format, time) 
vim.fn.strgetchar(str, index) 
vim.fn.stridx(haystack, needle, start) 
vim.fn.string(expr) 
vim.fn.strlen(string) 
vim.fn.strpart(src, start, len, chars) 
vim.fn.strptime(format, timestring) 
vim.fn.strridx(haystack, needle, start) 
vim.fn.strtrans(string) 
vim.fn.strutf16len(string, countcc) 
vim.fn.strwidth(string) 
vim.fn.submatch(nr, list) 
vim.fn.submatch(nr, list) 
vim.fn.substitute(string, pat, sub, flags) 
vim.fn.swapfilelist() 
vim.fn.swapinfo(fname) 
vim.fn.swapname(buf) 
vim.fn.synID(lnum, col, trans) 
vim.fn.synIDattr(synID, what, mode) 
vim.fn.synIDtrans(synID) 
vim.fn.synconcealed(lnum, col) 
vim.fn.synstack(lnum, col) 
vim.fn.system(cmd, input) 
vim.fn.systemlist(cmd, input, keepempty) 
vim.fn.tabpagebuflist(arg) 
vim.fn.tabpagenr(arg) 
vim.fn.tabpagewinnr(tabarg, arg) 
vim.fn.tagfiles() 
vim.fn.taglist(expr, filename) 
vim.fn.tan(expr) 
vim.fn.tanh(expr) 
vim.fn.tempname() 
vim.fn.termopen(cmd, opts) 
vim.fn.timer_info(id) 
vim.fn.timer_pause(timer, paused) 
vim.fn.timer_start(time, callback, options) 
vim.fn.timer_stop(timer) 
vim.fn.timer_stopall() 
vim.fn.tolower(expr) 
vim.fn.toupper(expr) 
vim.fn.tr(src, fromstr, tostr) 
vim.fn.trim(text, mask, dir) 
vim.fn.trunc(expr) 
vim.fn.type(expr) 
vim.fn.undofile(name) 
vim.fn.undotree(buf) 
vim.fn.uniq(list, func, dict) 
vim.fn.utf16idx(string, idx, countcc, charidx) 
vim.fn.values(dict) 
vim.fn.virtcol(expr, list, winid) 
vim.fn.virtcol2col(winid, lnum, col) 
vim.fn.visualmode(expr) 
vim.fn.wait(timeout, condition, interval) 
vim.fn.wildmenumode() 
vim.fn.win_execute(id, command, silent) 
vim.fn.win_findbuf(bufnr) 
vim.fn.win_getid(win, tab) 
vim.fn.win_gettype(nr) 
vim.fn.win_gotoid(expr) 
vim.fn.win_id2tabwin(expr) 
vim.fn.win_id2win(expr) 
vim.fn.win_move_separator(nr, offset) 
vim.fn.win_move_statusline(nr, offset) 
vim.fn.win_screenpos(nr) 
vim.fn.win_splitmove(nr, target, options) 
vim.fn.winbufnr(nr) 
vim.fn.wincol() 
vim.fn.windowsversion() 
vim.fn.winheight(nr) 
vim.fn.winlayout(tabnr) 
vim.fn.winline() 
vim.fn.winnr(arg) 
vim.fn.winrestcmd() 
vim.fn.winrestview(dict) 
vim.fn.winsaveview() 
vim.fn.winwidth(nr) 
vim.fn.wordcount() 
vim.fn.writefile(object, fname, flags) 
vim.fn.xor(expr, expr1) 
```