func (v *Nvim) AllOptionsInfo() (opinfo *OptionInfo, err error) {
	var result OptionInfo
	err = v.call("nvim_get_all_options_info", &result)
	return &result, err
}
AllOptionsInfo gets the option information for all options.

The dictionary has the full option names as keys and option metadata
dictionaries as detailed at OptionInfo.

Resulting map has keys:

name
Name of the option (like 'filetype').

shortname
Shortened name of the option (like 'ft').

type
type of option ("string", "number" or "boolean").

default
The default value for the option.

was_set
Whether the option was set.

last_set_sid
Last set script id (if any).

last_set_linenr
line number where option was set.

last_set_chan
Channel where option was set (0 for local).

scope
one of "global", "win", or "buf".

global_local
whether win or buf option has a global value.

commalist
List of comma separated values.

flaglist
List of single char flags.
package nvim
import (
	"fmt"
	"github.com/neovim/go-client/msgpack"
	"github.com/neovim/go-client/msgpack/rpc"
)
const (
	exceptionError  = 0
	validationError = 1
)
func withExtensions() rpc.Option {
	return rpc.WithExtensions(msgpack.ExtensionMap{
		0: func(p []byte) (interface{}, error) {
			x, err := decodeExt(p)
			return Buffer(x), err
		},
		2: func(p []byte) (interface{}, error) {
			x, err := decodeExt(p)
			return Tabpage(x), err
		},
		1: func(p []byte) (interface{}, error) {
			x, err := decodeExt(p)
			return Window(x), err
		},
	})
}
type Buffer int
func (x Buffer) MarshalMsgPack(enc *msgpack.Encoder) error {
	return enc.PackExtension(0, encodeExt(int(x)))
}
func (x *Buffer) UnmarshalMsgPack(dec *msgpack.Decoder) error {
	n, err := unmarshalExt(dec, 0, x)
	*x = Buffer(n)
	return err
}
func (x Buffer) String() string {
	return fmt.Sprintf("Buffer:%d", int(x))
}
type Tabpage int
func (x Tabpage) MarshalMsgPack(enc *msgpack.Encoder) error {
	return enc.PackExtension(2, encodeExt(int(x)))
}
func (x *Tabpage) UnmarshalMsgPack(dec *msgpack.Decoder) error {
	n, err := unmarshalExt(dec, 2, x)
	*x = Tabpage(n)
	return err
}
func (x Tabpage) String() string {
	return fmt.Sprintf("Tabpage:%d", int(x))
}
type Window int
func (x Window) MarshalMsgPack(enc *msgpack.Encoder) error {
	return enc.PackExtension(1, encodeExt(int(x)))
}
func (x *Window) UnmarshalMsgPack(dec *msgpack.Decoder) error {
	n, err := unmarshalExt(dec, 1, x)
	*x = Window(n)
	return err
}
func (x Window) String() string {
	return fmt.Sprintf("Window:%d", int(x))
}
func (v *Nvim) Exec(src string, output bool) (out string, err error) {
	err = v.call("nvim_exec", &out, src, output)
	return out, err
}
func (b *Batch) Exec(src string, output bool, out *string) {
	b.call("nvim_exec", out, src, output)
}
func (v *Nvim) Command(cmd string) error {
	return v.call("nvim_command", nil, cmd)
}
func (b *Batch) Command(cmd string) {
	b.call("nvim_command", nil, cmd)
}
func (v *Nvim) HLByID(id int, rgb bool) (highlight *HLAttrs, err error) {
	var result HLAttrs
	err = v.call("nvim_get_hl_by_id", &result, id, rgb)
	return &result, err
}
func (b *Batch) HLByID(id int, rgb bool, highlight *HLAttrs) {
	b.call("nvim_get_hl_by_id", highlight, id, rgb)
}
func (v *Nvim) HLIDByName(name string) (highlightID int, err error) {
	err = v.call("nvim_get_hl_id_by_name", &highlightID, name)
	return highlightID, err
}
func (b *Batch) HLIDByName(name string, highlightID *int) {
	b.call("nvim_get_hl_id_by_name", highlightID, name)
}
func (v *Nvim) HLByName(name string, rgb bool) (highlight *HLAttrs, err error) {
	var result HLAttrs
	err = v.call("nvim_get_hl_by_name", &result, name, rgb)
	return &result, err
}
func (b *Batch) HLByName(name string, rgb bool, highlight *HLAttrs) {
	b.call("nvim_get_hl_by_name", highlight, name, rgb)
}
func (v *Nvim) SetHighlight(nsID int, name string, val *HLAttrs) error {
	return v.call("nvim_set_hl", nil, nsID, name, val)
}
func (b *Batch) SetHighlight(nsID int, name string, val *HLAttrs) {
	b.call("nvim_set_hl", nil, nsID, name, val)
}
func (v *Nvim) SetHighlightNameSpace(nsID int) error {
	return v.call("nvim__set_hl_ns", nil, nsID)
}
func (b *Batch) SetHighlightNameSpace(nsID int) {
	b.call("nvim__set_hl_ns", nil, nsID)
}
func (v *Nvim) FeedKeys(keys string, mode string, escapeCSI bool) error {
	return v.call("nvim_feedkeys", nil, keys, mode, escapeCSI)
}
func (b *Batch) FeedKeys(keys string, mode string, escapeCSI bool) {
	b.call("nvim_feedkeys", nil, keys, mode, escapeCSI)
}
func (v *Nvim) Input(keys string) (written int, err error) {
	err = v.call("nvim_input", &written, keys)
	return written, err
}
func (b *Batch) Input(keys string, written *int) {
	b.call("nvim_input", written, keys)
}
func (v *Nvim) InputMouse(button string, action string, modifier string, grid int, row int, col int) error {
	return v.call("nvim_input_mouse", nil, button, action, modifier, grid, row, col)
}
func (b *Batch) InputMouse(button string, action string, modifier string, grid int, row int, col int) {
	b.call("nvim_input_mouse", nil, button, action, modifier, grid, row, col)
}
func (v *Nvim) ReplaceTermcodes(str string, fromPart bool, doLT bool, special bool) (input string, err error) {
	err = v.call("nvim_replace_termcodes", &input, str, fromPart, doLT, special)
	return input, err
}
func (b *Batch) ReplaceTermcodes(str string, fromPart bool, doLT bool, special bool, input *string) {
	b.call("nvim_replace_termcodes", input, str, fromPart, doLT, special)
}
func (v *Nvim) CommandOutput(cmd string) (out string, err error) {
	err = v.call("nvim_command_output", &out, cmd)
	return out, err
}
func (b *Batch) CommandOutput(cmd string, out *string) {
	b.call("nvim_command_output", out, cmd)
}
func (v *Nvim) Eval(expr string, result interface{}) error {
	return v.call("nvim_eval", result, expr)
}
func (b *Batch) Eval(expr string, result interface{}) {
	b.call("nvim_eval", &result, expr)
}
func (v *Nvim) StringWidth(s string) (width int, err error) {
	err = v.call("nvim_strwidth", &width, s)
	return width, err
}
func (b *Batch) StringWidth(s string, width *int) {
	b.call("nvim_strwidth", width, s)
}
func (v *Nvim) RuntimePaths() (paths []string, err error) {
	err = v.call("nvim_list_runtime_paths", &paths)
	return paths, err
}
func (b *Batch) RuntimePaths(paths *[]string) {
	b.call("nvim_list_runtime_paths", paths)
}
func (v *Nvim) RuntimeFiles(name string, all bool) (files []string, err error) {
	err = v.call("nvim_get_runtime_file", &files, name, all)
	return files, err
}
func (b *Batch) RuntimeFiles(name string, all bool, files *[]string) {
	b.call("nvim_get_runtime_file", files, name, all)
}
func (v *Nvim) SetCurrentDirectory(dir string) error {
	return v.call("nvim_set_current_dir", nil, dir)
}
func (b *Batch) SetCurrentDirectory(dir string) {
	b.call("nvim_set_current_dir", nil, dir)
}
func (v *Nvim) CurrentLine() (line []byte, err error) {
	err = v.call("nvim_get_current_line", &line)
	return line, err
}
func (b *Batch) CurrentLine(line *[]byte) {
	b.call("nvim_get_current_line", line)
}
func (v *Nvim) SetCurrentLine(line []byte) error {
	return v.call("nvim_set_current_line", nil, line)
}
func (b *Batch) SetCurrentLine(line []byte) {
	b.call("nvim_set_current_line", nil, line)
}
func (v *Nvim) DeleteCurrentLine() error {
	return v.call("nvim_del_current_line", nil)
}
func (b *Batch) DeleteCurrentLine() {
	b.call("nvim_del_current_line", nil)
}
func (v *Nvim) Var(name string, result interface{}) error {
	return v.call("nvim_get_var", result, name)
}
func (b *Batch) Var(name string, result interface{}) {
	b.call("nvim_get_var", &result, name)
}
func (v *Nvim) SetVar(name string, value interface{}) error {
	return v.call("nvim_set_var", nil, name, value)
}
func (b *Batch) SetVar(name string, value interface{}) {
	b.call("nvim_set_var", nil, name, value)
}
func (v *Nvim) DeleteVar(name string) error {
	return v.call("nvim_del_var", nil, name)
}
func (b *Batch) DeleteVar(name string) {
	b.call("nvim_del_var", nil, name)
}
func (v *Nvim) VVar(name string, result interface{}) error {
	return v.call("nvim_get_vvar", result, name)
}
func (b *Batch) VVar(name string, result interface{}) {
	b.call("nvim_get_vvar", &result, name)
}
func (v *Nvim) SetVVar(name string, value interface{}) error {
	return v.call("nvim_set_vvar", nil, name, value)
}
func (b *Batch) SetVVar(name string, value interface{}) {
	b.call("nvim_set_vvar", nil, name, value)
}
func (v *Nvim) Option(name string, result interface{}) error {
	return v.call("nvim_get_option", result, name)
}
func (b *Batch) Option(name string, result interface{}) {
	b.call("nvim_get_option", &result, name)
}