Parameters: ~
      • {lines}  (`string[]`) |readfile()|-style list of lines to paste.
                 |channel-lines|
      • {phase}  (`-1|1|2|3`) -1: "non-streaming" paste: the call contains all
                 lines. If paste is "streamed", `phase` indicates the stream
                 state:
                 • 1: starts the paste (exactly once)
                 • 2: continues the paste (zero or more times)
                 • 3: ends the paste (exactly once)

    Return: ~
        (`boolean`) result false if client should cancel the paste.

    See also: ~
      • |paste|

vim.print({...})                                                 *vim.print()*
    "Pretty prints" the given arguments and returns them unmodified.

    Example: >lua
        local hl_normal = vim.print(vim.api.nvim_get_hl(0, { name = 'Normal' }))
<

    Parameters: ~
      • {...}  (`any`)

    Return: ~
        (`any`) given arguments.

    See also: ~
      • |vim.inspect()|
      • |:=|

vim.schedule_wrap({fn})                                  *vim.schedule_wrap()*
    Returns a function which calls {fn} via |vim.schedule()|.

    The returned function passes all arguments to {fn}.

    Example: >lua
        function notify_readable(_err, readable)
          vim.notify("readable? " .. tostring(readable))
        end
        vim.uv.fs_access(vim.fn.stdpath("config"), "R", vim.schedule_wrap(notify_readable))
<

    Parameters: ~
      • {fn}  (`function`)

    Return: ~
        (`function`)

    See also: ~
      • |lua-loop-callbacks|
      • |vim.schedule()|
      • |vim.in_fast_event()|

                                                         *vim.str_byteindex()*
vim.str_byteindex({s}, {encoding}, {index}, {strict_indexing})
    Convert UTF-32, UTF-16 or UTF-8 {index} to byte index. If
    {strict_indexing} is false then then an out of range index will return
    byte length instead of throwing an error.

    Invalid UTF-8 and NUL is treated like in |vim.str_utfindex()|. An {index}
    in the middle of a UTF-16 sequence is rounded upwards to the end of that
    sequence.

    Parameters: ~
      • {s}                (`string`)
      • {encoding}         (`"utf-8"|"utf-16"|"utf-32"`)
      • {index}            (`integer`)
      • {strict_indexing}  (`boolean?`) default: true

    Return: ~
        (`integer`)

                                                          *vim.str_utfindex()*
vim.str_utfindex({s}, {encoding}, {index}, {strict_indexing})
    Convert byte index to UTF-32, UTF-16 or UTF-8 indices. If {index} is not
    supplied, the length of the string is used. All indices are zero-based.

    If {strict_indexing} is false then an out of range index will return
    string length instead of throwing an error. Invalid UTF-8 bytes, and
    embedded surrogates are counted as one code point each. An {index} in the
    middle of a UTF-8 sequence is rounded upwards to the end of that sequence.

    Parameters: ~
      • {s}                (`string`)
      • {encoding}         (`"utf-8"|"utf-16"|"utf-32"`)
      • {index}            (`integer?`)
      • {strict_indexing}  (`boolean?`) default: true

    Return: ~
        (`integer`)

vim.system({cmd}, {opts}, {on_exit})                            *vim.system()*
    Runs a system command or throws an error if {cmd} cannot be run.

    Examples: >lua
        local on_exit = function(obj)
          print(obj.code)
          print(obj.signal)
          print(obj.stdout)
          print(obj.stderr)
        end

        -- Runs asynchronously:
        vim.system({'echo', 'hello'}, { text = true }, on_exit)

        -- Runs synchronously:
        local obj = vim.system({'echo', 'hello'}, { text = true }):wait()
        -- { code = 0, signal = 0, stdout = 'hello\n', stderr = '' }
<

    See |uv.spawn()| for more details. Note: unlike |uv.spawn()|, vim.system
    throws an error if {cmd} cannot be run.

    Parameters: ~
      • {cmd}      (`string[]`) Command to execute
      • {opts}     (`vim.SystemOpts?`)