gen_vimdoc.py: sort by name

2 files changed, 1043 insertions, 1043 deletions

diff --git a/runtime/doc/api.txt b/runtime/doc/api.txt
index aa69186cf0..7d45330b66 100644
--- a/runtime/doc/api.txt
+++ b/runtime/doc/api.txt
@@ -479,166 +479,201 @@ created for extmark changes.
 ==============================================================================
 Global Functions                                                  *api-global*
 
-nvim_exec({src}, {output})                                       *nvim_exec()*
-                Executes Vimscript (multiline block of Ex-commands), like
-                anonymous |:source|.
+nvim__id({obj})                                                   *nvim__id()*
+                Returns object given as argument.
 
-                Unlike |nvim_command()| this function supports heredocs,
-                script-scope (s:), etc.
+                This API function is used for testing. One should not rely on
+                its presence in plugins.
 
-                On execution error: fails with VimL error, does not update
-                v:errmsg.
+                Parameters: ~
+                    {obj}  Object to return.
+
+                Return: ~
+                    its argument.
+
+nvim__id_array({arr})                                       *nvim__id_array()*
+                Returns array given as argument.
+
+                This API function is used for testing. One should not rely on
+                its presence in plugins.
 
                 Parameters: ~
-                    {src}     Vimscript code
-                    {output}  Capture and return all (non-error, non-shell
-                              |:!|) output
+                    {arr}  Array to return.
 
                 Return: ~
-                    Output (non-error, non-shell |:!|) if `output` is true,
-                    else empty string.
+                    its argument.
 
-                See also: ~
-                    |execute()|
-                    |nvim_command()|
+nvim__id_dictionary({dct})                             *nvim__id_dictionary()*
+                Returns dictionary given as argument.
 
-nvim_command({command})                                       *nvim_command()*
-                Executes an ex-command.
+                This API function is used for testing. One should not rely on
+                its presence in plugins.
 
-                On execution error: fails with VimL error, does not update
-                v:errmsg.
+                Parameters: ~
+                    {dct}  Dictionary to return.
+
+                Return: ~
+                    its argument.
+
+nvim__id_float({flt})                                       *nvim__id_float()*
+                Returns floating-point value given as argument.
+
+                This API function is used for testing. One should not rely on
+                its presence in plugins.
 
                 Parameters: ~
-                    {command}  Ex-command string
+                    {flt}  Value to return.
 
-                See also: ~
-                    |nvim_exec()|
+                Return: ~
+                    its argument.
 
-nvim_get_hl_by_name({name}, {rgb})                     *nvim_get_hl_by_name()*
-                Gets a highlight definition by name.
+nvim__inspect_cell({grid}, {row}, {col})                *nvim__inspect_cell()*
+                TODO: Documentation
+
+nvim__put_attr({id}, {c0}, {c1})                            *nvim__put_attr()*
+                Set attrs in nvim__buf_set_lua_hl callbacks
+
+                TODO(bfredl): This is rather pedestrian. The final interface
+                should probably be derived from a reformed bufhl/virttext
+                interface with full support for multi-line ranges etc
+
+nvim__stats()                                                  *nvim__stats()*
+                Gets internal stats.
+
+                Return: ~
+                    Map of various internal stats.
+
+nvim_call_atomic({calls})                                 *nvim_call_atomic()*
+                Calls many API methods atomically.
+
+                This has two main usages:
+                1. To perform several requests from an async context
+                   atomically, i.e. without interleaving redraws, RPC requests
+                   from other clients, or user interactions (however API
+                   methods may trigger autocommands or event processing which
+                   have such side-effects, e.g. |:sleep| may wake timers).
+                2. To minimize RPC overhead (roundtrips) of a sequence of many
+                   requests.
 
                 Parameters: ~
-                    {name}  Highlight group name
-                    {rgb}   Export RGB colors
+                    {calls}  an array of calls, where each call is described
+                             by an array with two elements: the request name,
+                             and an array of arguments.
 
                 Return: ~
-                    Highlight definition map
+                    Array of two elements. The first is an array of return
+                    values. The second is NIL if all calls succeeded. If a
+                    call resulted in an error, it is a three-element array
+                    with the zero-based index of the call which resulted in an
+                    error, the error type and the error message. If an error
+                    occurred, the values from all preceding calls will still
+                    be returned.
 
-                See also: ~
-                    nvim_get_hl_by_id
+nvim_call_dict_function({dict}, {fn}, {args})      *nvim_call_dict_function()*
+                Calls a VimL |Dictionary-function| with the given arguments.
 
-nvim_get_hl_by_id({hl_id}, {rgb})                        *nvim_get_hl_by_id()*
-                Gets a highlight definition by id. |hlID()|
+                On execution error: fails with VimL error, does not update
+                v:errmsg.
 
                 Parameters: ~
-                    {hl_id}  Highlight id as returned by |hlID()|
-                    {rgb}    Export RGB colors
+                    {dict}  Dictionary, or String evaluating to a VimL |self|
+                            dict
+                    {fn}    Name of the function defined on the VimL dict
+                    {args}  Function arguments packed in an Array
 
                 Return: ~
-                    Highlight definition map
+                    Result of the function call
 
-                See also: ~
-                    nvim_get_hl_by_name
+nvim_call_function({fn}, {args})                        *nvim_call_function()*
+                Calls a VimL function with the given arguments.
 
-nvim_get_hl_id_by_name({name})                      *nvim_get_hl_id_by_name()*
-                Gets a highlight group by name
+                On execution error: fails with VimL error, does not update
+                v:errmsg.
 
-                similar to |hlID()|, but allocates a new ID if not present.
+                Parameters: ~
+                    {fn}    Function to call
+                    {args}  Function arguments packed in an Array
 
-nvim_feedkeys({keys}, {mode}, {escape_csi})                  *nvim_feedkeys()*
-                Sends input-keys to Nvim, subject to various quirks controlled
-                by `mode` flags. This is a blocking call, unlike
-                |nvim_input()|.
+                Return: ~
+                    Result of the function call
 
-                On execution error: does not fail, but updates v:errmsg.
+nvim_command({command})                                       *nvim_command()*
+                Executes an ex-command.
+
+                On execution error: fails with VimL error, does not update
+                v:errmsg.
 
                 Parameters: ~
-                    {keys}        to be typed
-                    {mode}        behavior flags, see |feedkeys()|
-                    {escape_csi}  If true, escape K_SPECIAL/CSI bytes in
-                                  `keys`
+                    {command}  Ex-command string
 
                 See also: ~
-                    feedkeys()
-                    vim_strsave_escape_csi
+                    |nvim_exec()|
 
-nvim_input({keys})                                              *nvim_input()*
-                Queues raw user-input. Unlike |nvim_feedkeys()|, this uses a
-                low-level input buffer and the call is non-blocking (input is
-                processed asynchronously by the eventloop).
+nvim_create_buf({listed}, {scratch})                       *nvim_create_buf()*
+                Creates a new, empty, unnamed buffer.
 
-                On execution error: does not fail, but updates v:errmsg.
+                Parameters: ~
+                    {listed}   Sets 'buflisted'
+                    {scratch}  Creates a "throwaway" |scratch-buffer| for
+                               temporary work (always 'nomodified')
 
-                Note:
-                    |keycodes| like <CR> are translated, so "<" is special. To
-                    input a literal "<", send <LT>.
-                Note:
-                    For mouse events use |nvim_input_mouse()|. The pseudokey
-                    form "<LeftMouse><col,row>" is deprecated since
-                    |api-level| 6.
+                Return: ~
+                    Buffer handle, or 0 on error
 
-                Attributes: ~
-                    {fast}
+                See also: ~
+                    buf_open_scratch
+
+nvim_create_namespace({name})                        *nvim_create_namespace()*
+                Creates a new namespace, or gets an existing one.
+
+                Namespaces are used for buffer highlights and virtual text,
+                see |nvim_buf_add_highlight()| and
+                |nvim_buf_set_virtual_text()|.
+
+                Namespaces can be named or anonymous. If `name` matches an
+                existing namespace, the associated id is returned. If `name`
+                is an empty string a new, anonymous namespace is created.
 
                 Parameters: ~
-                    {keys}  to be typed
+                    {name}  Namespace name or empty string
 
                 Return: ~
-                    Number of bytes actually written (can be fewer than
-                    requested if the buffer becomes full).
+                    Namespace id
 
-                                                          *nvim_input_mouse()*
-nvim_input_mouse({button}, {action}, {modifier}, {grid}, {row}, {col})
-                Send mouse event from GUI.
+nvim_del_current_line()                              *nvim_del_current_line()*
+                Deletes the current line.
 
-                Non-blocking: does not wait on any result, but queues the
-                event to be processed soon by the event loop.
+nvim_del_keymap({mode}, {lhs})                             *nvim_del_keymap()*
+                Unmaps a global |mapping| for the given mode.
 
-                Note:
-                    Currently this doesn't support "scripting" multiple mouse
-                    events by calling it multiple times in a loop: the
-                    intermediate mouse positions will be ignored. It should be
-                    used to implement real-time mouse input in a GUI. The
-                    deprecated pseudokey form ("<LeftMouse><col,row>") of
-                    |nvim_input()| has the same limitiation.
+                To unmap a buffer-local mapping, use |nvim_buf_del_keymap()|.
 
-                Attributes: ~
-                    {fast}
+                See also: ~
+                    |nvim_set_keymap()|
+
+nvim_del_var({name})                                          *nvim_del_var()*
+                Removes a global (g:) variable.
 
                 Parameters: ~
-                    {button}    Mouse button: one of "left", "right",
-                                "middle", "wheel".
-                    {action}    For ordinary buttons, one of "press", "drag",
-                                "release". For the wheel, one of "up", "down",
-                                "left", "right".
-                    {modifier}  String of modifiers each represented by a
-                                single char. The same specifiers are used as
-                                for a key press, except that the "-" separator
-                                is optional, so "C-A-", "c-a" and "CA" can all
-                                be used to specify Ctrl+Alt+click.
-                    {grid}      Grid number if the client uses |ui-multigrid|,
-                                else 0.
-                    {row}       Mouse row-position (zero-based, like redraw
-                                events)
-                    {col}       Mouse column-position (zero-based, like redraw
-                                events)
+                    {name}  Variable name
 
-                                                    *nvim_replace_termcodes()*
-nvim_replace_termcodes({str}, {from_part}, {do_lt}, {special})
-                Replaces terminal codes and |keycodes| (<CR>, <Esc>, ...) in a
-                string with the internal representation.
+nvim_err_write({str})                                       *nvim_err_write()*
+                Writes a message to the Vim error buffer. Does not append
+                "\n", the message is buffered (won't display) until a linefeed
+                is written.
 
                 Parameters: ~
-                    {str}        String to be converted.
-                    {from_part}  Legacy Vim parameter. Usually true.
-                    {do_lt}      Also translate <lt>. Ignored if `special` is
-                                 false.
-                    {special}    Replace |keycodes|, e.g. <CR> becomes a "\n"
-                                 char.
+                    {str}  Message
+
+nvim_err_writeln({str})                                   *nvim_err_writeln()*
+                Writes a message to the Vim error buffer. Appends "\n", so the
+                buffer is flushed (and displayed).
+
+                Parameters: ~
+                    {str}  Message
 
                 See also: ~
-                    replace_termcodes
-                    cpoptions
+                    nvim_err_write()
 
 nvim_eval({expr})                                                *nvim_eval()*
                 Evaluates a VimL |expression|. Dictionaries and Lists are
@@ -653,6 +688,29 @@ nvim_eval({expr})                                                *nvim_eval()*
                 Return: ~
                     Evaluation result or expanded object
 
+nvim_exec({src}, {output})                                       *nvim_exec()*
+                Executes Vimscript (multiline block of Ex-commands), like
+                anonymous |:source|.
+
+                Unlike |nvim_command()| this function supports heredocs,
+                script-scope (s:), etc.
+
+                On execution error: fails with VimL error, does not update
+                v:errmsg.
+
+                Parameters: ~
+                    {src}     Vimscript code
+                    {output}  Capture and return all (non-error, non-shell
+                              |:!|) output
+
+                Return: ~
+                    Output (non-error, non-shell |:!|) if `output` is true,
+                    else empty string.
+
+                See also: ~
+                    |execute()|
+                    |nvim_command()|
+
 nvim_exec_lua({code}, {args})                                *nvim_exec_lua()*
                 Execute Lua code. Parameters (if any) are available as `...`
                 inside the chunk. The chunk can return a value.
@@ -667,55 +725,115 @@ nvim_exec_lua({code}, {args})                                *nvim_exec_lua()*
                 Return: ~
                     Return value of Lua code if present or NIL.
 
-nvim_call_function({fn}, {args})                        *nvim_call_function()*
-                Calls a VimL function with the given arguments.
+nvim_feedkeys({keys}, {mode}, {escape_csi})                  *nvim_feedkeys()*
+                Sends input-keys to Nvim, subject to various quirks controlled
+                by `mode` flags. This is a blocking call, unlike
+                |nvim_input()|.
 
-                On execution error: fails with VimL error, does not update
-                v:errmsg.
+                On execution error: does not fail, but updates v:errmsg.
 
                 Parameters: ~
-                    {fn}    Function to call
-                    {args}  Function arguments packed in an Array
+                    {keys}        to be typed
+                    {mode}        behavior flags, see |feedkeys()|
+                    {escape_csi}  If true, escape K_SPECIAL/CSI bytes in
+                                  `keys`
+
+                See also: ~
+                    feedkeys()
+                    vim_strsave_escape_csi
+
+nvim_get_api_info()                                      *nvim_get_api_info()*
+                Returns a 2-tuple (Array), where item 0 is the current channel
+                id and item 1 is the |api-metadata| map (Dictionary).
 
                 Return: ~
-                    Result of the function call
+                    2-tuple [{channel-id}, {api-metadata}]
 
-nvim_call_dict_function({dict}, {fn}, {args})      *nvim_call_dict_function()*
-                Calls a VimL |Dictionary-function| with the given arguments.
+                Attributes: ~
+                    {fast}
 
-                On execution error: fails with VimL error, does not update
-                v:errmsg.
+nvim_get_chan_info({chan})                              *nvim_get_chan_info()*
+                Get information about a channel.
+
+                Return: ~
+                    Dictionary describing a channel, with these keys:
+                    • "stream" the stream underlying the channel
+                      • "stdio" stdin and stdout of this Nvim instance
+                      • "stderr" stderr of this Nvim instance
+                      • "socket" TCP/IP socket or named pipe
+                      • "job" job with communication over its stdio
+
+                    • "mode" how data received on the channel is interpreted
+                      • "bytes" send and receive raw bytes
+                      • "terminal" a |terminal| instance interprets ASCII
+                        sequences
+                      • "rpc" |RPC| communication on the channel is active
+
+                    • "pty" Name of pseudoterminal, if one is used (optional).
+                      On a POSIX system, this will be a device path like
+                      /dev/pts/1. Even if the name is unknown, the key will
+                      still be present to indicate a pty is used. This is
+                      currently the case when using winpty on windows.
+                    • "buffer" buffer with connected |terminal| instance
+                      (optional)
+                    • "client" information about the client on the other end
+                      of the RPC channel, if it has added it using
+                      |nvim_set_client_info()|. (optional)
+
+nvim_get_color_by_name({name})                      *nvim_get_color_by_name()*
+                Returns the 24-bit RGB value of a |nvim_get_color_map()| color
+                name or "#rrggbb" hexadecimal string.
+
+                Example: >
+                    :echo nvim_get_color_by_name("Pink")
+                    :echo nvim_get_color_by_name("#cbcbcb")
+<
 
                 Parameters: ~
-                    {dict}  Dictionary, or String evaluating to a VimL |self|
-                            dict
-                    {fn}    Name of the function defined on the VimL dict
-                    {args}  Function arguments packed in an Array
+                    {name}  Color name or "#rrggbb" string
 
                 Return: ~
-                    Result of the function call
+                    24-bit RGB value, or -1 for invalid argument.
 
-nvim_strwidth({text})                                        *nvim_strwidth()*
-                Calculates the number of display cells occupied by `text` .
-                <Tab> counts as one cell.
+nvim_get_color_map()                                    *nvim_get_color_map()*
+                Returns a map of color names and RGB values.
 
-                Parameters: ~
-                    {text}  Some text
+                Keys are color names (e.g. "Aqua") and values are 24-bit RGB
+                color values (e.g. 65535).
 
                 Return: ~
-                    Number of cells
+                    Map of color names and RGB values.
 
-nvim_list_runtime_paths()                          *nvim_list_runtime_paths()*
-                Gets the paths contained in 'runtimepath'.
+nvim_get_commands({opts})                                *nvim_get_commands()*
+                Gets a map of global (non-buffer-local) Ex commands.
+
+                Currently only |user-commands| are supported, not builtin Ex
+                commands.
+
+                Parameters: ~
+                    {opts}  Optional parameters. Currently only supports
+                            {"builtin":false}
 
                 Return: ~
-                    List of paths
+                    Map of maps describing commands.
 
-nvim_set_current_dir({dir})                           *nvim_set_current_dir()*
-                Changes the global working directory.
+nvim_get_context({opts})                                  *nvim_get_context()*
+                Gets a map of the current editor state.
 
                 Parameters: ~
-                    {dir}  Directory path
+                    {opts}  Optional parameters.
+                            • types: List of |context-types| ("regs", "jumps",
+                              "bufs", "gvars", …) to gather, or empty for
+                              "all".
+
+                Return: ~
+                    map of global |context|.
+
+nvim_get_current_buf()                                *nvim_get_current_buf()*
+                Gets the current buffer.
+
+                Return: ~
+                    Buffer handle
 
 nvim_get_current_line()                              *nvim_get_current_line()*
                 Gets the current line.
@@ -723,52 +841,75 @@ nvim_get_current_line()                              *nvim_get_current_line()*
                 Return: ~
                     Current line string
 
-nvim_set_current_line({line})                        *nvim_set_current_line()*
-                Sets the current line.
+nvim_get_current_tabpage()                        *nvim_get_current_tabpage()*
+                Gets the current tabpage.
 
-                Parameters: ~
-                    {line}  Line contents
+                Return: ~
+                    Tabpage handle
 
-nvim_del_current_line()                              *nvim_del_current_line()*
-                Deletes the current line.
+nvim_get_current_win()                                *nvim_get_current_win()*
+                Gets the current window.
 
-nvim_get_var({name})                                          *nvim_get_var()*
-                Gets a global (g:) variable.
+                Return: ~
+                    Window handle
+
+nvim_get_hl_by_id({hl_id}, {rgb})                        *nvim_get_hl_by_id()*
+                Gets a highlight definition by id. |hlID()|
 
                 Parameters: ~
-                    {name}  Variable name
+                    {hl_id}  Highlight id as returned by |hlID()|
+                    {rgb}    Export RGB colors
 
                 Return: ~
-                    Variable value
+                    Highlight definition map
 
-nvim_set_var({name}, {value})                                 *nvim_set_var()*
-                Sets a global (g:) variable.
+                See also: ~
+                    nvim_get_hl_by_name
+
+nvim_get_hl_by_name({name}, {rgb})                     *nvim_get_hl_by_name()*
+                Gets a highlight definition by name.
 
                 Parameters: ~
-                    {name}   Variable name
-                    {value}  Variable value
+                    {name}  Highlight group name
+                    {rgb}   Export RGB colors
 
-nvim_del_var({name})                                          *nvim_del_var()*
-                Removes a global (g:) variable.
+                Return: ~
+                    Highlight definition map
 
-                Parameters: ~
-                    {name}  Variable name
+                See also: ~
+                    nvim_get_hl_by_id
 
-nvim_get_vvar({name})                                        *nvim_get_vvar()*
-                Gets a v: variable.
+nvim_get_hl_id_by_name({name})                      *nvim_get_hl_id_by_name()*
+                Gets a highlight group by name
+
+                similar to |hlID()|, but allocates a new ID if not present.
+
+nvim_get_keymap({mode})                                    *nvim_get_keymap()*
+                Gets a list of global (non-buffer-local) |mapping|
+                definitions.
 
                 Parameters: ~
-                    {name}  Variable name
+                    {mode}  Mode short-name ("n", "i", "v", ...)
 
                 Return: ~
-                    Variable value
+                    Array of maparg()-like dictionaries describing mappings.
+                    The "buffer" key is always zero.
 
-nvim_set_vvar({name}, {value})                               *nvim_set_vvar()*
-                Sets a v: variable, if it is not readonly.
+nvim_get_mode()                                              *nvim_get_mode()*
+                Gets the current mode. |mode()| "blocking" is true if Nvim is
+                waiting for input.
 
-                Parameters: ~
-                    {name}   Variable name
-                    {value}  Variable value
+                Return: ~
+                    Dictionary { "mode": String, "blocking": Boolean }
+
+                Attributes: ~
+                    {fast}
+
+nvim_get_namespaces()                                  *nvim_get_namespaces()*
+                Gets existing, non-anonymous namespaces.
+
+                Return: ~
+                    dict that maps from names to namespace ids.
 
 nvim_get_option({name})                                    *nvim_get_option()*
                 Gets an option value string.
@@ -779,38 +920,96 @@ nvim_get_option({name})                                    *nvim_get_option()*
                 Return: ~
                     Option value (global)
 
-nvim_set_option({name}, {value})                           *nvim_set_option()*
-                Sets an option value.
+nvim_get_proc({pid})                                         *nvim_get_proc()*
+                Gets info describing process `pid` .
 
-                Parameters: ~
-                    {name}   Option name
-                    {value}  New option value
+                Return: ~
+                    Map of process properties, or NIL if process not found.
 
-nvim_out_write({str})                                       *nvim_out_write()*
-                Writes a message to the Vim output buffer. Does not append
-                "\n", the message is buffered (won't display) until a linefeed
-                is written.
+nvim_get_proc_children({pid})                       *nvim_get_proc_children()*
+                Gets the immediate children of process `pid` .
+
+                Return: ~
+                    Array of child process ids, empty if process not found.
+
+nvim_get_var({name})                                          *nvim_get_var()*
+                Gets a global (g:) variable.
 
                 Parameters: ~
-                    {str}  Message
+                    {name}  Variable name
 
-nvim_err_write({str})                                       *nvim_err_write()*
-                Writes a message to the Vim error buffer. Does not append
-                "\n", the message is buffered (won't display) until a linefeed
-                is written.
+                Return: ~
+                    Variable value
+
+nvim_get_vvar({name})                                        *nvim_get_vvar()*
+                Gets a v: variable.
 
                 Parameters: ~
-                    {str}  Message
+                    {name}  Variable name
 
-nvim_err_writeln({str})                                   *nvim_err_writeln()*
-                Writes a message to the Vim error buffer. Appends "\n", so the
-                buffer is flushed (and displayed).
+                Return: ~
+                    Variable value
+
+nvim_input({keys})                                              *nvim_input()*
+                Queues raw user-input. Unlike |nvim_feedkeys()|, this uses a
+                low-level input buffer and the call is non-blocking (input is
+                processed asynchronously by the eventloop).
+
+                On execution error: does not fail, but updates v:errmsg.
+
+                Note:
+                    |keycodes| like <CR> are translated, so "<" is special. To
+                    input a literal "<", send <LT>.
+                Note:
+                    For mouse events use |nvim_input_mouse()|. The pseudokey
+                    form "<LeftMouse><col,row>" is deprecated since
+                    |api-level| 6.
+
+                Attributes: ~
+                    {fast}
 
                 Parameters: ~
-                    {str}  Message
+                    {keys}  to be typed
 
-                See also: ~
-                    nvim_err_write()
+                Return: ~
+                    Number of bytes actually written (can be fewer than
+                    requested if the buffer becomes full).
+
+                                                          *nvim_input_mouse()*
+nvim_input_mouse({button}, {action}, {modifier}, {grid}, {row}, {col})
+                Send mouse event from GUI.
+
+                Non-blocking: does not wait on any result, but queues the
+                event to be processed soon by the event loop.
+
+                Note:
+                    Currently this doesn't support "scripting" multiple mouse
+                    events by calling it multiple times in a loop: the
+                    intermediate mouse positions will be ignored. It should be
+                    used to implement real-time mouse input in a GUI. The
+                    deprecated pseudokey form ("<LeftMouse><col,row>") of
+                    |nvim_input()| has the same limitiation.
+
+                Attributes: ~
+                    {fast}
+
+                Parameters: ~
+                    {button}    Mouse button: one of "left", "right",
+                                "middle", "wheel".
+                    {action}    For ordinary buttons, one of "press", "drag",
+                                "release". For the wheel, one of "up", "down",
+                                "left", "right".
+                    {modifier}  String of modifiers each represented by a
+                                single char. The same specifiers are used as
+                                for a key press, except that the "-" separator
+                                is optional, so "C-A-", "c-a" and "CA" can all
+                                be used to specify Ctrl+Alt+click.
+                    {grid}      Grid number if the client uses |ui-multigrid|,
+                                else 0.
+                    {row}       Mouse row-position (zero-based, like redraw
+                                events)
+                    {col}       Mouse column-position (zero-based, like redraw
+                                events)
 
 nvim_list_bufs()                                            *nvim_list_bufs()*
                 Gets the current list of buffer handles
@@ -821,49 +1020,48 @@ nvim_list_bufs()                                            *nvim_list_bufs()*
                 Return: ~
                     List of buffer handles
 
-nvim_get_current_buf()                                *nvim_get_current_buf()*
-                Gets the current buffer.
+nvim_list_chans()                                          *nvim_list_chans()*
+                Get information about all open channels.
 
                 Return: ~
-                    Buffer handle
+                    Array of Dictionaries, each describing a channel with the
+                    format specified at |nvim_get_chan_info()|.
 
-nvim_set_current_buf({buffer})                        *nvim_set_current_buf()*
-                Sets the current buffer.
+nvim_list_runtime_paths()                          *nvim_list_runtime_paths()*
+                Gets the paths contained in 'runtimepath'.
 
-                Parameters: ~
-                    {buffer}  Buffer handle
+                Return: ~
+                    List of paths
 
-nvim_list_wins()                                            *nvim_list_wins()*
-                Gets the current list of window handles.
+nvim_list_tabpages()                                    *nvim_list_tabpages()*
+                Gets the current list of tabpage handles.
 
                 Return: ~
-                    List of window handles
+                    List of tabpage handles
 
-nvim_get_current_win()                                *nvim_get_current_win()*
-                Gets the current window.
+nvim_list_uis()                                              *nvim_list_uis()*
+                Gets a list of dictionaries representing attached UIs.
 
                 Return: ~
-                    Window handle
+                    Array of UI dictionaries, each with these keys:
+                    • "height" Requested height of the UI
+                    • "width" Requested width of the UI
+                    • "rgb" true if the UI uses RGB colors (false implies
+                      |cterm-colors|)
+                    • "ext_..." Requested UI extensions, see |ui-option|
+                    • "chan" Channel id of remote UI (not present for TUI)
 
-nvim_set_current_win({window})                        *nvim_set_current_win()*
-                Sets the current window.
+nvim_list_wins()                                            *nvim_list_wins()*
+                Gets the current list of window handles.
 
-                Parameters: ~
-                    {window}  Window handle
+                Return: ~
+                    List of window handles
 
-nvim_create_buf({listed}, {scratch})                       *nvim_create_buf()*
-                Creates a new, empty, unnamed buffer.
+nvim_load_context({dict})                                *nvim_load_context()*
+                Sets the current editor state from the given |context| map.
 
                 Parameters: ~
-                    {listed}   Sets 'buflisted'
-                    {scratch}  Creates a "throwaway" |scratch-buffer| for
-                               temporary work (always 'nomodified')
-
-                Return: ~
-                    Buffer handle, or 0 on error
-
-                See also: ~
-                    buf_open_scratch
+                    {dict}  |Context| map.
 
 nvim_open_win({buffer}, {enter}, {config})                   *nvim_open_win()*
                 Open a new window.
@@ -916,7 +1114,7 @@ nvim_open_win({buffer}, {enter}, {config})                   *nvim_open_win()*
                                 • "cursor" Cursor position in current window.
 
                               • `win` : |window-ID| for relative="win".
-                              •  `anchor` : Decides which corner of the float to place
+                              • `anchor`: Decides which corner of the float to place
                                 at (row,col):
                                 • "NW" northwest (default)
                                 • "NE" northeast
@@ -946,7 +1144,7 @@ nvim_open_win({buffer}, {enter}, {config})                   *nvim_open_win()*
                                 an external top-level window. Currently
                                 accepts no other positioning configuration
                                 together with this.
-                              •  `style` : Configure the appearance of the window.
+                              • `style`: Configure the appearance of the window.
                                 Currently only takes one non-empty value:
                                 • "minimal" Nvim will display the window with
                                   many UI options disabled. This is useful
@@ -964,46 +1162,110 @@ nvim_open_win({buffer}, {enter}, {config})                   *nvim_open_win()*
                 Return: ~
                     Window handle, or 0 on error
 
-nvim_list_tabpages()                                    *nvim_list_tabpages()*
-                Gets the current list of tabpage handles.
-
-                Return: ~
-                    List of tabpage handles
-
-nvim_get_current_tabpage()                        *nvim_get_current_tabpage()*
-                Gets the current tabpage.
-
-                Return: ~
-                    Tabpage handle
-
-nvim_set_current_tabpage({tabpage})               *nvim_set_current_tabpage()*
-                Sets the current tabpage.
+nvim_out_write({str})                                       *nvim_out_write()*
+                Writes a message to the Vim output buffer. Does not append
+                "\n", the message is buffered (won't display) until a linefeed
+                is written.
 
                 Parameters: ~
-                    {tabpage}  Tabpage handle
-
-nvim_create_namespace({name})                        *nvim_create_namespace()*
-                Creates a new namespace, or gets an existing one.
+                    {str}  Message
 
-                Namespaces are used for buffer highlights and virtual text,
-                see |nvim_buf_add_highlight()| and
-                |nvim_buf_set_virtual_text()|.
+                                                     *nvim_parse_expression()*
+nvim_parse_expression({expr}, {flags}, {highlight})
+                Parse a VimL expression.
 
-                Namespaces can be named or anonymous. If `name` matches an
-                existing namespace, the associated id is retu