// NOTE: This file is generated. Do NOT modify it manually.
// deno-lint-ignore-file camelcase
import type { Denops } from "https://deno.land/x/denops_core@v4.0.0/mod.ts";

/**
 * Return the absolute value of **{expr}**.  When **{expr}** evaluates to
 * a `Float` abs() returns a `Float`.  When **{expr}** can be
 * converted to a `Number` abs() returns a `Number`.  Otherwise
 * abs() gives an error message and returns -1.
 * Examples:
 *
 *     echo abs(1.456)
 *
 *         1.456
 *
 *     echo abs(-5.456)
 *
 *         5.456
 *
 *     echo abs(-4)
 *
 *         4
 *
 * Can also be used as a `method`:
 *
 *     Compute()->abs()
 *
 * *only available when compiled with the `+float` feature*
 */
export function abs(denops: Denops, expr: unknown): Promise<unknown>;
export function abs(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("abs", ...args);
}

/**
 * Return the arc cosine of **{expr}** measured in radians, as a
 * `Float` in the range of [0, pi].
 * **{expr}** must evaluate to a `Float` or a `Number` in the range
 * [-1, 1].  Otherwise acos() returns "nan".
 * Examples:
 *
 *     :echo acos(0)
 *
 *         1.570796
 *
 *     :echo acos(-0.5)
 *
 *         2.094395
 *
 * Can also be used as a `method`:
 *
 *     Compute()->acos()
 *
 * *only available when compiled with the `+float` feature*
 */
export function acos(denops: Denops, expr: unknown): Promise<unknown>;
export function acos(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("acos", ...args);
}

/**
 * Append the item **{expr}** to `List` or `Blob` **{object}**.  Returns
 * the resulting `List` or `Blob`.  Examples:
 *
 *     :let alist = add([1, 2, 3], item)
 *     :call add(mylist, "woodstock")
 *
 * Note that when **{expr}** is a `List` it is appended as a single
 * item.  Use `extend()` to concatenate `Lists`.
 * When **{object}** is a `Blob` then  **{expr}** must be a number.
 * Use `insert()` to add an item at another position.
 * Returns 1 if **{object}** is not a `List` or a `Blob`.
 *
 * Can also be used as a `method`:
 *
 *     mylist->add(val1)->add(val2)
 */
export function add(
  denops: Denops,
  object: unknown,
  expr: unknown,
): Promise<unknown>;
export function add(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("add", ...args);
}

/**
 * Bitwise AND on the two arguments.  The arguments are converted
 * to a number.  A List, Dict or Float argument causes an error.
 * Also see `or()` and `xor()`.
 * Example:
 *
 *     :let flag = and(bits, 0x80)
 *
 * Can also be used as a `method`:
 *
 *     :let flag = bits->and(0x80)
 */
export function and(
  denops: Denops,
  expr1: unknown,
  expr2: unknown,
): Promise<unknown>;
export function and(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("and", ...args);
}

/**
 * When **{text}** is a `List`: Append each item of the `List` as a
 * text line below line **{lnum}** in the current buffer.
 * Otherwise append **{text}** as one text line below line **{lnum}** in
 * the current buffer.
 * Any type of item is accepted and converted to a String.
 * **{lnum}** can be zero to insert a line before the first one.
 * **{lnum}** is used like with `getline()`.
 * Returns 1 for failure (**{lnum}** out of range or out of memory),
 * 0 for success.  In `Vim9` script an invalid argument or
 * negative number results in an error.  Example:
 *
 *     :let failed = append(line('$'), "# THE END")
 *     :let failed = append(0, ["Chapter 1", "the beginning"])
 *
 * Can also be used as a `method` after a List, the base is
 * passed as the second argument:
 *
 *     mylist->append(lnum)
 */
export function append(
  denops: Denops,
  lnum: unknown,
  text: unknown,
): Promise<unknown>;
export function append(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("append", ...args);
}

/**
 * Like `append()` but append the text in buffer **{buf}**.
 *
 * This function works only for loaded buffers. First call
 * `bufload()` if needed.
 *
 * For the use of **{buf}**, see `bufname()`.
 *
 * **{lnum}** is the line number to append below.  Note that using
 * `line()` would use the current buffer, not the one appending
 * to.  Use "$" to append at the end of the buffer.  Other string
 * values are not supported.
 *
 * On success 0 is returned, on failure 1 is returned.
 * In `Vim9` script an error is given for an invalid **{lnum}**.
 *
 * If **{buf}** is not a valid buffer or **{lnum}** is not valid, an
 * error message is given. Example:
 *
 *     :let failed = appendbufline(13, 0, "# THE START")
 *
 * Can also be used as a `method` after a List, the base is
 * passed as the second argument:
 *
 *     mylist->appendbufline(buf, lnum)
 */
export function appendbufline(
  denops: Denops,
  buf: unknown,
  lnum: unknown,
  text: unknown,
): Promise<unknown>;
export function appendbufline(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("appendbufline", ...args);
}

/**
 * The result is the number of files in the argument list.  See
 * `arglist`.
 * If **{winid}** is not supplied, the argument list of the current
 * window is used.
 * If **{winid}** is -1, the global argument list is used.
 * Otherwise **{winid}** specifies the window of which the argument
 * list is used: either the window number or the window ID.
 * Returns -1 if the **{winid}** argument is invalid.
 */
export function argc(denops: Denops, winid?: unknown): Promise<unknown>;
export function argc(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("argc", ...args);
}

/**
 * The result is the current index in the argument list.  0 is
 * the first file.  argc() - 1 is the last one.  See `arglist`.
 */
export function argidx(denops: Denops): Promise<unknown>;
export function argidx(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("argidx", ...args);
}

/**
 * Return the argument list ID.  This is a number which
 * identifies the argument list being used.  Zero is used for the
 * global argument list.  See `arglist`.
 * Returns -1 if the arguments are invalid.
 *
 * Without arguments use the current window.
 * With **{winnr}** only use this window in the current tab page.
 * With **{winnr}** and **{tabnr}** use the window in the specified tab
 * page.
 * **{winnr}** can be the window number or the `window-ID`.
 */
export function arglistid(
  denops: Denops,
  winnr?: unknown,
  tabnr?: unknown,
): Promise<unknown>;
export function arglistid(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("arglistid", ...args);
}

/**
 * The result is the **{nr}**th file in the argument list.  See
 * `arglist`.  "argv(0)" is the first one.  Example:
 *
 *     :let i = 0
 *     :while i < argc()
 *     :  let f = escape(fnameescape(argv(i)), '.')
 *     :  exe 'amenu Arg.' .. f .. ' :e ' .. f .. '<CR>'
 *     :  let i = i + 1
 *     :endwhile
 *
 * Without the **{nr}** argument, or when **{nr}** is -1, a `List` with
 * the whole `arglist` is returned.
 *
 * The **{winid}** argument specifies the window ID, see `argc()`.
 * For the Vim command line arguments see `v:argv`.
 *
 * Returns an empty string if **{nr}**th argument is not present in
 * the argument list.  Returns an empty List if the **{winid}**
 * argument is invalid.
 */
export function argv(
  denops: Denops,
  nr?: unknown,
  winid?: unknown,
): Promise<unknown>;
export function argv(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("argv", ...args);
}

/**
 * Return the arc sine of **{expr}** measured in radians, as a `Float`
 * in the range of [-pi/2, pi/2].
 * **{expr}** must evaluate to a `Float` or a `Number` in the range
 * [-1, 1].
 * Returns "nan" if **{expr}** is outside the range [-1, 1].  Returns
 * 0.0 if **{expr}** is not a `Float` or a `Number`.
 * Examples:
 *
 *     :echo asin(0.8)
 *
 *         0.927295
 *
 *     :echo asin(-0.5)
 *
 *         -0.523599
 *
 * Can also be used as a `method`:
 *
 *     Compute()->asin()
 *
 * *only available when compiled with the `+float` feature*
 */
export function asin(denops: Denops, expr: unknown): Promise<unknown>;
export function asin(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("asin", ...args);
}

/**
 * Return the principal value of the arc tangent of **{expr}**, in
 * the range [-pi/2, +pi/2] 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:
 *
 *     :echo atan(100)
 *
 *         1.560797
 *
 *     :echo atan(-4.01)
 *
 *         -1.326405
 *
 * Can also be used as a `method`:
 *
 *     Compute()->atan()
 *
 * *only available when compiled with the `+float` feature*
 */
export function atan(denops: Denops, expr: unknown): Promise<unknown>;
export function atan(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("atan", ...args);
}

/**
 * Return the arc tangent of **{expr1}** / **{expr2}**, measured in
 * radians, as a `Float` in the range [-pi, pi].
 * **{expr1}** and **{expr2}** must evaluate to a `Float` or a `Number`.
 * Returns 0.0 if **{expr1}** or **{expr2}** is not a `Float` or a
 * `Number`.
 * Examples:
 *
 *     :echo atan2(-1, 1)
 *
 *         -0.785398
 *
 *     :echo atan2(1, -1)
 *
 *         2.356194
 *
 * Can also be used as a `method`:
 *
 *     Compute()->atan2(1)
 *
 * *only available when compiled with the `+float` feature*
 */
export function atan2(
  denops: Denops,
  expr1: unknown,
  expr2: unknown,
): Promise<unknown>;
export function atan2(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("atan2", ...args);
}

/**
 * Put up a file requester.  This only works when "has("browse")"
 * returns `TRUE` (only in some GUI versions).
 * The input fields are:
 *     **{save}**      when `TRUE`, select file to write
 *     **{title}**     title for the requester
 *     **{initdir}**   directory to start browsing in
 *     **{default}**   default file name
 * An empty string is returned when the "Cancel" button is hit,
 * something went wrong, or browsing is not possible.
 */
export function browse(
  denops: Denops,
  save: unknown,
  title: unknown,
  initdir: unknown,
  defaultValue: unknown,
): Promise<unknown>;
export function browse(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("browse", ...args);
}

/**
 * Put up a directory requester.  This only works when
 * "has("browse")" returns `TRUE` (only in some GUI versions).
 * On systems where a directory browser is not supported a file
 * browser is used.  In that case: select a file in the directory
 * to be used.
 * The input fields are:
 *     **{title}**     title for the requester
 *     **{initdir}**   directory to start browsing in
 * When the "Cancel" button is hit, something went wrong, or
 * browsing is not possible, an empty string is returned.
 */
export function browsedir(
  denops: Denops,
  title: unknown,
  initdir: unknown,
): Promise<unknown>;
export function browsedir(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("browsedir", ...args);
}

/**
 * Return byte index of the **{nr}**'th character in the String
 * **{expr}**.  Use zero for the first character, it then returns
 * zero.
 * If there are no multibyte characters the returned value is
 * equal to **{nr}**.
 * Composing characters are not counted separately, their byte
 * length is added to the preceding base character.  See
 * `byteidxcomp()` below for counting composing characters
 * separately.
 * Example :
 *
 *     echo matchstr(str, ".", byteidx(str, 3))
 *
 * will display the fourth character.  Another way to do the
 * same:
 *
 *     let s = strpart(str, byteidx(str, 3))
 *     echo strpart(s, 0, byteidx(s, 1))
 *
 * Also see `strgetchar()` and `strcharpart()`.
 *
 * If there are less than **{nr}** characters -1 is returned.
 * If there are exactly **{nr}** characters the length of the string
 * in bytes is returned.
 *
 * Can also be used as a `method`:
 *
 *     GetName()->byteidx(idx)
 */
export function byteidx(
  denops: Denops,
  expr: unknown,
  nr: unknown,
): Promise<unknown>;
export function byteidx(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("byteidx", ...args);
}

/**
 * Like byteidx(), except that a composing character is counted
 * as a separate character.  Example:
 *
 *     let s = 'e' .. nr2char(0x301)
 *     echo byteidx(s, 1)
 *     echo byteidxcomp(s, 1)
 *     echo byteidxcomp(s, 2)
 *
 * The first and third echo result in 3 ('e' plus composing
 * character is 3 bytes), the second echo results in 1 ('e' is
 * one byte).
 * Only works differently from byteidx() when 'encoding' is set
 * to a Unicode encoding.
 *
 * Can also be used as a `method`:
 *
 *     GetName()->byteidxcomp(idx)
 */
export function byteidxcomp(
  denops: Denops,
  expr: unknown,
  nr: unknown,
): Promise<unknown>;
export function byteidxcomp(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("byteidxcomp", ...args);
}

/**
 * Call function **{func}** with the items in `List` **{arglist}** as
 * arguments.
 * **{func}** can either be a `Funcref` or the name of a function.
 * a:firstline and a:lastline are set to the cursor line.
 * Returns the return value of the called function.
 * **{dict}** is for functions with the "dict" attribute.  It will be
 * used to set the local variable "self". `Dictionary-function`
 *
 * Can also be used as a `method`:
 *
 *     GetFunc()->call([arg, arg], dict)
 */
export function call(
  denops: Denops,
  func: unknown,
  arglist: unknown,
  dict?: unknown,
): Promise<unknown>;
export function call(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("call", ...args);
}

/**
 * Return the smallest integral value greater than or equal to
 * **{expr}** as a `Float` (round up).
 * **{expr}** must evaluate to a `Float` or a `Number`.
 * Examples:
 *
 *     echo ceil(1.456)
 *
 *         2.0
 *
 *     echo ceil(-5.456)
 *
 *         -5.0
 *
 *     echo ceil(4.0)
 *
 *         4.0
 *
 * Returns 0.0 if **{expr}** is not a `Float` or a `Number`.
 *
 * Can also be used as a `method`:
 *
 *     Compute()->ceil()
 *
 * *only available when compiled with the `+float` feature*
 */
export function ceil(denops: Denops, expr: unknown): Promise<unknown>;
export function ceil(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("ceil", ...args);
}

/**
 * Return the number of the most recent change.  This is the same
 * number as what is displayed with `:undolist` and can be used
 * with the `:undo` command.
 * When a change was made it is the number of that change.  After
 * redo it is the number of the redone change.  After undo it is
 * one less than the number of the undone change.
 * Returns 0 if the undo list is empty.
 */
export function changenr(denops: Denops): Promise<unknown>;
export function changenr(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("changenr", ...args);
}

/**
 * Return Number value of the first char in **{string}**.
 * Examples:
 *
 *     char2nr(" ")            returns 32
 *     char2nr("ABC")          returns 65
 *
 * When **{utf8}** is omitted or zero, the current 'encoding' is used.
 * Example for "utf-8":
 *
 *     char2nr("á")            returns 225
 *     char2nr("á"[0])         returns 195
 *
 * When **{utf8}** is TRUE, always treat as UTF-8 characters.
 * A combining character is a separate character.
 * `nr2char()` does the opposite.
 * To turn a string into a list of character numbers:
 *
 *     let str = "ABC"
 *     let list = map(split(str, '\zs'), {_, val -> char2nr(val)})
 *
 * Result: [65, 66, 67]
 *
 * Returns 0 if **{string}** is not a `String`.
 *
 * Can also be used as a `method`:
 *
 *     GetChar()->char2nr()
 */
export function char2nr(
  denops: Denops,
  string: unknown,
  utf8?: unknown,
): Promise<unknown>;
export function char2nr(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("char2nr", ...args);
}

/**
 * Return the character class of the first character in **{string}**.
 * The character class is one of:
 *         0       blank
 *         1       punctuation
 *         2       word character
 *         3       emoji
 *         other   specific Unicode class
 * The class is used in patterns and word motions.
 * Returns 0 if **{string}** is not a `String`.
 */
export function charclass(denops: Denops, string: unknown): Promise<unknown>;
export function charclass(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("charclass", ...args);
}

/**
 * Same as `col()` but returns the character index of the column
 * position given with **{expr}** instead of the byte position.
 *
 * Example:
 * With the cursor on '세' in line 5 with text "여보세요":
 *
 *     charcol('.')            returns 3
 *     col('.')                returns 7
 *
 * Can also be used as a `method`:
 *
 *     GetPos()->col()
 */
export function charcol(denops: Denops, expr: unknown): Promise<unknown>;
export function charcol(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("charcol", ...args);
}

/**
 * Return the character index of the byte at **{idx}** in **{string}**.
 * The index of the first character is zero.
 * If there are no multibyte characters the returned value is
 * equal to **{idx}**.
 * When **{countcc}** is omitted or `FALSE`, then composing characters
 * are not counted separately, their byte length is
 * added to the preceding base character.
 * When **{countcc}** is `TRUE`, then composing characters are
 * counted as separate characters.
 * Returns -1 if the arguments are invalid or if **{idx}** is greater
 * than the index of the last byte in **{string}**.  An error is
 * given if the first argument is not a string, the second
 * argument is not a number or when the third argument is present
 * and is not zero or one.
 * See `byteidx()` and `byteidxcomp()` for getting the byte index
 * from the character index.
 * Examples:
 *
 *     echo charidx('áb́ć', 3)               returns 1
 *     echo charidx('áb́ć', 6, 1)    returns 4
 *     echo charidx('áb́ć', 16)              returns -1
 *
 * Can also be used as a `method`:
 *
 *     GetName()->charidx(idx)
 */
export function charidx(
  denops: Denops,
  string: unknown,
  idx: unknown,
  countcc?: unknown,
): Promise<unknown>;
export function charidx(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("charidx", ...args);
}

/**
 * Change the current working directory to **{dir}**.  The scope of
 * the directory change depends on the directory of the current
 * window:
 *         - If the current window has a window-local directory
 *           (`:lcd`), then changes the window local directory.
 *         - Otherwise, if the current tabpage has a local
 *           directory (`:tcd`) then changes the tabpage local
 *           directory.
 *         - Otherwise, changes the global directory.
 * **{dir}** must be a String.
 * If successful, returns the previous working directory.  Pass
 * this to another chdir() to restore the directory.
 * On failure, returns an empty string.
 *
 * Example:
 *
 *     let save_dir = chdir(newdir)
 *     if save_dir != ""
 *        " ... do some work
 *        call chdir(save_dir)
 *     endif
 *
 * Can also be used as a `method`:
 *
 *     GetDir()->chdir()
 */
export function chdir(denops: Denops, dir: unknown): Promise<unknown>;
export function chdir(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("chdir", ...args);
}

/**
 * Get the amount of indent for line **{lnum}** according the C
 * indenting rules, as with 'cindent'.
 * The indent is counted in spaces, the value of 'tabstop' is
 * relevant.  **{lnum}** is used just like in `getline()`.
 * When **{lnum}** is invalid -1 is returned.
 * See `C-indenting`.
 *
 * Can also be used as a `method`:
 *
 *     GetLnum()->cindent()
 */
export function cindent(denops: Denops, lnum: unknown): Promise<unknown>;
export function cindent(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("cindent", ...args);
}

/**
 * Clears all matches previously defined for the current window
 * by `matchadd()` and the `:match` commands.
 * 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`:
 *
 *     GetWin()->clearmatches()
 */
export function clearmatches(denops: Denops, win?: unknown): Promise<unknown>;
export function clearmatches(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("clearmatches", ...args);
}

/**
 * Set the matches for Insert mode completion.
 * Can only be used in Insert mode.  You need to use a mapping
 * with CTRL-R = (see `i_CTRL-R`).  It does not work after CTRL-O
 * or with an expression mapping.
 * **{startcol}** is the byte offset in the line where the completed
 * text start.  The text up to the cursor is the original text
 * that will be replaced by the matches.  Use col('.') for an
 * empty string.  "col('.') - 1" will replace one character by a
 * match.
 * **{matches}** must be a `List`.  Each `List` item is one match.
 * See `complete-items` for the kind of items that are possible.
 * "longest" in 'completeopt' is ignored.
 * Note that the after calling this function you need to avoid
 * inserting anything that would cause completion to stop.
 * The match can be selected with CTRL-N and CTRL-P as usual with
 * Insert mode completion.  The popup menu will appear if
 * specified, see `ins-completion-menu`.
 * Example:
 *
 *     inoremap <F5> <C-R>=ListMonths()<CR>
 *
 *     func! ListMonths()
 *       call complete(col('.'), ['January', 'February', 'March',
 *             \ 'April', 'May', 'June', 'July', 'August', 'September',
 *             \ 'October', 'November', 'December'])
 *       return ''
 *     endfunc
 *
 * This isn't very useful, but it shows how it works.  Note that
 * an empty string is returned to avoid a zero being inserted.
 *
 * Can also be used as a `method`, the base is passed as the
 * second argument:
 *
 *     GetMatches()->complete(col('.'))
 */
export function complete(
  denops: Denops,
  startcol: unknown,
  matches: unknown,
): Promise<unknown>;
export function complete(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("complete", ...args);
}

/**
 * Add **{expr}** to the list of matches.  Only to be used by the
 * function specified with the 'completefunc' option.
 * Returns 0 for failure (empty string or out of memory),
 * 1 when the match was added, 2 when the match was already in
 * the list.
 * See `complete-functions` for an explanation of **{expr}**.  It is
 * the same as one item in the list that 'omnifunc' would return.
 *
 * Can also be used as a `method`:
 *
 *     GetMoreMatches()->complete_add()
 */
export function complete_add(denops: Denops, expr: unknown): Promise<unknown>;
export function complete_add(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("complete_add", ...args);
}

/**
 * Check for a key typed while looking for completion matches.
 * This is to be used when looking for matches takes some time.
 * Returns `TRUE` when searching for matches is to be aborted,
 * zero otherwise.
 * Only to be used by the function specified with the
 * 'completefunc' option.
 */
export function complete_check(denops: Denops): Promise<unknown>;
export function complete_check(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("complete_check", ...args);
}

/**
 * Returns a `Dictionary` with information about Insert mode
 * completion.  See `ins-completion`.
 * The items are:
 *    mode         Current completion mode name string.
 *                 See `complete_info_mode` for the values.
 *    pum_visible  `TRUE` if popup menu is visible.
 *                 See `pumvisible()`.
 *    items        List of completion matches.  Each item is a
 *                 dictionary containing the entries "word",
 *                 "abbr", "menu", "kind", "info" and "user_data".
 *                 See `complete-items`.
 *    selected     Selected item index.  First index is zero.
 *                 Index is -1 if no item is selected (showing
 *                 typed text only, or the last completion after
 *                 no item is selected when using the `<Up>` or
 *                 `<Down>` keys)
 *    inserted     Inserted string. [NOT IMPLEMENTED YET]
 *
 * mode values are:
 *    ""                Not in completion mode
 *    "keyword"         Keyword completion `i_CTRL-X_CTRL-N`
 *    "ctrl_x"          Just pressed CTRL-X `i_CTRL-X`
 *    "scroll"          Scrolling with `i_CTRL-X_CTRL-E` or
 *                      `i_CTRL-X_CTRL-Y`
 *    "whole_line"      Whole lines `i_CTRL-X_CTRL-L`
 *    "files"           File names `i_CTRL-X_CTRL-F`
 *    "tags"            Tags `i_CTRL-X_CTRL-]`
 *    "path_defines"    Definition completion `i_CTRL-X_CTRL-D`
 *    "path_patterns"   Include completion `i_CTRL-X_CTRL-I`
 *    "dictionary"      Dictionary `i_CTRL-X_CTRL-K`
 *    "thesaurus"       Thesaurus `i_CTRL-X_CTRL-T`
 *    "cmdline"         Vim Command line `i_CTRL-X_CTRL-V`
 *    "function"        User defined completion `i_CTRL-X_CTRL-U`
 *    "omni"            Omni completion `i_CTRL-X_CTRL-O`
 *    "spell"           Spelling suggestions `i_CTRL-X_s`
 *    "eval"            `complete()` completion
 *    "unknown"         Other internal modes
 *
 * If the optional **{what}** list argument is supplied, then only
 * the items listed in **{what}** are returned.  Unsupported items in
 * **{what}** are silently ignored.
 *
 * To get the position and size of the popup menu, see
 * `pum_getpos()`. It's also available in `v:event` during the
 * `CompleteChanged` event.
 *
 * Returns an empty `Dictionary` on error.
 *
 * Examples:
 *
 *     " Get all items
 *     call complete_info()
 *     " Get only 'mode'
 *     call complete_info(['mode'])
 *     " Get only 'mode' and 'pum_visible'
 *     call complete_info(['mode', 'pum_visible'])
 *
 * Can also be used as a `method`:
 *
 *     GetItems()->complete_info()
 */
export function complete_info(denops: Denops, what?: unknown): Promise<unknown>;
export function complete_info(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("complete_info", ...args);
}

/**
 * confirm() offers the user a dialog, from which a choice can be
 * made.  It returns the number of the choice.  For the first
 * choice this is 1.
 * Note: confirm() is only supported when compiled with dialog
 * support, see `+dialog_con` and `+dialog_gui`.
 *
 * **{msg}** is displayed in a `dialog` with **{choices}** as the
 * alternatives.  When **{choices}** is missing or empty, "&OK" is
 * used (and translated).
 * **{msg}** is a String, use '\n' to include a newline.  Only on
 * some systems the string is wrapped when it doesn't fit.
 *
 * **{choices}** is a String, with the individual choices separated
 * by '\n', e.g.
 *
 *     confirm("Save changes?", "&Yes\n&No\n&Cancel")
 *
 * The letter after the '&' is the shortcut key for that choice.
 * Thus you can type 'c' to select "Cancel".  The shortcut does
 * not need to be the first letter:
 *
 *     confirm("file has been modified", "&Save\nSave &All")
 *
 * For the console, the first letter of each choice is used as
 * the default shortcut key.  Case is ignored.
 *
 * The optional **{default}** argument is the number of the choice
 * that is made if the user hits `<CR>`.  Use 1 to make the first
 * choice the default one.  Use 0 to not set a default.  If
 * **{default}** is omitted, 1 is used.
 *
 * The optional **{type}** String argument gives the type of dialog.
 * This is only used for the icon of the GTK, Mac, Motif and
 * Win32 GUI.  It can be one of these values: "Error",
 * "Question", "Info", "Warning" or "Generic".  Only the first
 * character is relevant.  When **{type}** is omitted, "Generic" is
 * used.
 *
 * If the user aborts the dialog by pressing `<Esc>`, CTRL-C,
 * or another valid interrupt key, confirm() returns 0.
 *
 * An example:
 *
 *     let choice = confirm("What do you want?",
 *                          \ "&Apples\n&Oranges\n&Bananas", 2)
 *     if choice == 0
 *          echo "make up your mind!"
 *     elseif choice == 3
 *          echo "tasteful"
 *     else
 *          echo "I prefer bananas myself."
 *     endif
 *
 * In a GUI dialog, buttons are used.  The layout of the buttons
 * depends on the 'v' flag in 'guioptions'.  If it is included,
 * the buttons are always put vertically.  Otherwise,  confirm()
 * tries to put the buttons in one horizontal line.  If they
 * don't fit, a vertical layout is used anyway.  For some systems
 * the horizontal layout is always used.
 *
 * Can also be used as a `method`in:
 *
 *     BuildMessage()->confirm("&Yes\n&No")
 */
export function confirm(
  denops: Denops,
  msg: unknown,
  choices?: unknown,
  defaultValue?: unknown,
  type?: unknown,
): Promise<unknown>;
export function confirm(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("confirm", ...args);
}

/**
 * Make a copy of **{expr}**.  For Numbers and Strings this isn't
 * different from using **{expr}** directly.
 * When **{expr}** is a `List` a shallow copy is created.  This means
 * that the original `List` can be changed without changing the
 * copy, and vice versa.  But the items are identical, thus
 * changing an item changes the contents of both `Lists`.
 * A `Dictionary` is copied in a similar way as a `List`.
 * Also see `deepcopy()`.
 * Can also be used as a `method`:
 *
 *     mylist->copy()
 */
export function copy(denops: Denops, expr: unknown): Promise<unknown>;
export function copy(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("copy", ...args);
}

/**
 * Return the cosine 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:
 *
 *     :echo cos(100)
 *
 *         0.862319
 *
 *     :echo cos(-4.01)
 *
 *         -0.646043
 *
 * Can also be used as a `method`:
 *
 *     Compute()->cos()
 *
 * *only available when compiled with the `+float` feature*
 */
export function cos(denops: Denops, expr: unknown): Promise<unknown>;
export function cos(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("cos", ...args);
}

/**
 * Return the hyperbolic cosine of **{expr}** as a `Float` in the range
 * [1, inf].
 * **{expr}** must evaluate to a `Float` or a `Number`.
 * Returns 0.0 if **{expr}** is not a `Float` or a `Number`.
 * Examples:
 *
 *     :echo cosh(0.5)
 *
 *         1.127626
 *
 *     :echo cosh(-0.5)
 *
 *         -1.127626
 *
 * Can also be used as a `method`:
 *
 *     Compute()->cosh()
 *
 * *only available when compiled with the `+float` feature*
 */
export function cosh(denops: Denops, expr: unknown): Promise<unknown>;
export function cosh(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("cosh", ...args);
}

/**
 * Return the number of times an item with value **{expr}** appears
 * in `String`, `List` or `Dictionary` **{comp}**.
 *
 * If **{start}** is given then start with the item with this index.
 * **{start}** can only be used with a `List`.
 *
 * When **{ic}** is given and it's `TRUE` then case is ignored.
 *
 * When **{comp}** is a string then the number of not overlapping
 * occurrences of **{expr}** is returned. Zero is returned when
 * **{expr}** is an empty string.
 *
 * Can also be used as a `method`:
 *
 *     mylist->count(val)
 */
export function count(
  denops: Denops,
  comp: unknown,
  expr: unknown,
  ic?: unknown,
  start?: unknown,
): Promise<unknown>;
export function count(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("count", ...args);
}

/**
 * Checks for the existence of a `cscope` connection.  If no
 * parameters are specified, then the function returns:
 *         0, if cscope was not available (not compiled in), or
 *            if there are no cscope connections;
 *         1, if there is at least one cscope connection.
 *
 * If parameters are specified, then the value of **{num}**
 * determines how existence of a cscope connection is checked:
 *
 * **{num}**   Description of existence check
 * -----   ------------------------------
 * 0       Same as no parameters (e.g., "cscope_connection()").
 * 1       Ignore **{prepend}**, and use partial string matches for
 *         **{dbpath}**.
 * 2       Ignore **{prepend}**, and use exact string matches for
 *         **{dbpath}**.
 * 3       Use **{prepend}**, use partial string matches for both
 *         **{dbpath}** and **{prepend}**.
 * 4       Use **{prepend}**, use exact string matches for both
 *         **{dbpath}** and **{prepend}**.
 *
 * Note: All string comparisons are case sensitive!
 *
 * Examples.  Suppose we had the following (from ":cs show"):
 *
 *     # pid    database name                        prepend path
 *     0 27664  cscope.out                           /usr/local
 *
 * Invocation                                      Return Val
 * ----------                                      ----------
 *
 *     cscope_connection()                                     1
 *     cscope_connection(1, "out")                             1
 *     cscope_connection(2, "out")                             0
 *     cscope_connection(3, "out")                             0
 *     cscope_connection(3, "out", "local")                    1
 *     cscope_connection(4, "out")                             0
 *     cscope_connection(4, "out", "local")                    0
 *     cscope_connection(4, "cscope.out", "/usr/local")        1
 */
export function cscope_connection(
  denops: Denops,
  num?: unknown,
  dbpath?: unknown,
  prepend?: unknown,
): Promise<unknown>;
export function cscope_connection(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("cscope_connection", ...args);
}

/**
 * Specifically used to interrupt a program being debugged.  It
 * will cause process **{pid}** to get a SIGTRAP.  Behavior for other
 * processes is undefined. See `terminal-debugger`.
 * *only available on MS-Windows*
 *
 * Returns `TRUE` if successfully interrupted the program.
 * Otherwise returns `FALSE`.
 *
 * Can also be used as a `method`:
 *
 *     GetPid()->debugbreak()
 */
export function debugbreak(denops: Denops, pid: unknown): Promise<unknown>;
export function debugbreak(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("debugbreak", ...args);
}

/**
 * Make a copy of **{expr}**.  For Numbers and Strings this isn't
 * different from using **{expr}** directly.
 * When **{expr}** is a `List` a full copy is created.  This means
 * that the original `List` can be changed without changing the
 * copy, and vice versa.  When an item is a `List` or
 * `Dictionary`, a copy for it is made, recursively.  Thus
 * changing an item in the copy does not change the contents of
 * the original `List`.
 * A `Dictionary` is copied in a similar way as a `List`.
 *
 * When **{noref}** is omitted or zero a contained `List` or
 * `Dictionary` is only copied once.  All references point to
 * this single copy.  With **{noref}** set to 1 every occurrence of a
 * `List` or `Dictionary` results in a new copy.  This also means
 * that a cyclic reference causes deepcopy() to fail.
 *
 * Nesting is possible up to 100 levels.  When there is an item
 * that refers back to a higher level making a deep copy with
 * **{noref}** set to 1 will fail.
 * Also see `copy()`.
 *
 * Can also be used as a `method`:
 *
 *     GetObject()->deepcopy()
 */
export function deepcopy(
  denops: Denops,
  expr: unknown,
  noref?: unknown,
): Promise<unknown>;
export function deepcopy(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("deepcopy", ...args);
}

/**
 * Without **{flags}** or with **{flags}** empty: Deletes the file by the
 * name **{fname}**.
 *
 * This also works when **{fname}** is a symbolic link.  The symbolic
 * link itself is deleted, not what it points to.
 *
 * When **{flags}** is "d": Deletes the directory by the name
 * **{fname}**.  This fails when directory **{fname}** is not empty.
 *
 * When **{flags}** is "rf": Deletes the directory by the name
 * **{fname}** and everything in it, recursively.  BE CAREFUL!
 * Note: on MS-Windows it is not possible to delete a directory
 * that is being used.
 *
 * The result is a Number, which is 0/false if the delete
 * operation was successful and -1/true when the deletion failed
 * or partly failed.
 *
 * Use `remove()` to delete an item from a `List`.
 * To delete a line from the buffer use `:delete` or
 * `deletebufline()`.
 *
 * Can also be used as a `method`:
 *
 *     GetName()->delete()
 */
export function delete_(
  denops: Denops,
  fname: unknown,
  flags?: unknown,
): Promise<unknown>;
export function delete_(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("delete_", ...args);
}

/**
 * Delete lines **{first}** to **{last}** (inclusive) from buffer **{buf}**.
 * If **{last}** is omitted then delete line **{first}** only.
 * On success 0 is returned, on failure 1 is returned.
 *
 * This function works only for loaded buffers. First call
 * `bufload()` if needed.
 *
 * For the use of **{buf}**, see `bufname()` above.
 *
 * **{first}** and **{last}** are used like with `getline()`. Note that
 * when using `line()` this refers to the current buffer. Use "$"
 * to refer to the last line in buffer **{buf}**.
 *
 * Can also be used as a `method`:
 *
 *     GetBuffer()->deletebufline(1)
 */
export function deletebufline(
  denops: Denops,
  buf: unknown,
  first: unknown,
  last?: unknown,
): Promise<unknown>;
export function deletebufline(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("deletebufline", ...args);
}

/**
 * Returns `TRUE` when autocommands are being executed and the
 * FileType event has been triggered at least once.  Can be used
 * to avoid triggering the FileType event again in the scripts
 * that detect the file type. `FileType`
 * Returns `FALSE` when `:setf FALLBACK` was used.
 * When editing another file, the counter is reset, thus this
 * really checks if the FileType event has been triggered for the
 * current buffer.  This allows an autocommand that starts
 * editing another buffer to set 'filetype' and load a syntax
 * file.
 */
export function did_filetype(denops: Denops): Promise<unknown>;
export function did_filetype(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("did_filetype", ...args);
}

/**
 * Returns the highlight ID for diff mode at line **{lnum}** column
 * **{col}** (byte index).  When the current line does not have a
 * diff change zero is returned.
 * **{lnum}** is used like with `getline()`.  Thus "." is the current
 * line, "'m" mark m, etc.
 * **{col}** is 1 for the leftmost column, **{lnum}** is 1 for the first
 * line.
 * The highlight ID can be used with `synIDattr()` to obtain
 * syntax information about the highlighting.
 *
 * Can also be used as a `method`:
 *
 *     GetLnum()->diff_hlID(col)
 */
export function diff_hlID(
  denops: Denops,
  lnum: unknown,
  col: unknown,
): Promise<unknown>;
export function diff_hlID(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("diff_hlID", ...args);
}

/**
 * Return the digraph of **{chars}**.  This should be a string with
 * exactly two characters.  If **{chars}** are not just two
 * characters, or the digraph of **{chars}** does not exist, an error
 * is given and an empty string is returned.
 *
 * The character will be converted from Unicode to 'encoding'
 * when needed.  This does require the conversion to be
 * available, it might fail.
 *
 * Also see `digraph_getlist()`.
 *
 * Examples:
 *
 *     " Get a built-in digraph
 *     :echo digraph_get('00')         " Returns '∞'
 *
 *     " Get a user-defined digraph
 *     :call digraph_set('aa', 'あ')
 *     :echo digraph_get('aa')         " Returns 'あ'
 *
 * Can also be used as a `method`:
 *
 *     GetChars()->digraph_get()
 *
 * This function works only when compiled with the `+digraphs`
 * feature.  If this feature is disabled, this function will
 * display an error message.
 */
export function digraph_get(denops: Denops, chars: unknown): Promise<unknown>;
export function digraph_get(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("digraph_get", ...args);
}

/**
 * Return a list of digraphs.  If the **{listall}** argument is given
 * and it is TRUE, return all digraphs, including the default
 * digraphs.  Otherwise, return only user-defined digraphs.
 *
 * The characters will be converted from Unicode to 'encoding'
 * when needed.  This does require the conservation to be
 * available, it might fail.
 *
 * Also see `digraph_get()`.
 *
 * Examples:
 *
 *     " Get user-defined digraphs
 *     :echo digraph_getlist()
 *
 *     " Get all the digraphs, including default digraphs
 *     :echo digraph_getlist(1)
 *
 * Can also be used as a `method`:
 *
 *     GetNumber()->digraph_getlist()
 *
 * This function works only when compiled with the `+digraphs`
 * feature.  If this feature is disabled, this function will
 * display an error message.
 */
export function digraph_getlist(
  denops: Denops,
  listall?: unknown,
): Promise<unknown>;
export function digraph_getlist(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("digraph_getlist", ...args);
}

/**
 * Add digraph **{chars}** to the list.  **{chars}** must be a string
 * with two characters.  **{digraph}** is a string with one UTF-8
 * encoded character.
 * Be careful, composing characters are NOT ignored.  This
 * function is similar to `:digraphs` command, but useful to add
 * digraphs start with a white space.
 *
 * The function result is v:true if `digraph` is registered.  If
 * this fails an error message is given and v:false is returned.
 *
 * If you want to define multiple digraphs at once, you can use
 * `digraph_setlist()`.
 *
 * Example:
 *
 *     call digraph_set('  ', 'あ')
 *
 * Can be used as a `method`:
 *
 *     GetString()->digraph_set('あ')
 *
 * This function works only when compiled with the `+digraphs`
 * feature.  If this feature is disabled, this function will
 * display an error message.
 */
export function digraph_set(
  denops: Denops,
  chars: unknown,
  digraph: unknown,
): Promise<unknown>;
export function digraph_set(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("digraph_set", ...args);
}

/**
 * Similar to `digraph_set()` but this function can add multiple
 * digraphs at once.  **{digraphlist}** is a list composed of lists,
 * where each list contains two strings with **{chars}** and
 * **{digraph}** as in `digraph_set()`.
 * Example:
 *
 *     call digraph_setlist([['aa', 'あ'], ['ii', 'い']])
 *
 * It is similar to the following:
 *
 *     for [chars, digraph] in [['aa', 'あ'], ['ii', 'い']]
 *           call digraph_set(chars, digraph)
 *     endfor
 *
 * Except that the function returns after the first error,
 * following digraphs will not be added.
 *
 * Can be used as a `method`:
 *
 *     GetList()->digraph_setlist()
 *
 * This function works only when compiled with the `+digraphs`
 * feature.  If this feature is disabled, this function will
 * display an error message.
 */
export function digraph_setlist(
  denops: Denops,
  digraphlist: unknown,
): Promise<unknown>;
export function digraph_setlist(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("digraph_setlist", ...args);
}

/**
 * Return the Number 1 if **{expr}** is empty, zero otherwise.
 * - A `List` or `Dictionary` is empty when it does not have any
 *   items.
 * - A `String` is empty when its length is zero.
 * - A `Number` and `Float` are empty when their value is zero.
 * - `v:false`, `v:none` and `v:null` are empty, `v:true` is not.
 * - A `Job` is empty when it failed to start.
 * - A `Channel` is empty when it is closed.
 * - A `Blob` is empty when its length is zero.
 *
 * For a long `List` this is much faster than comparing the
 * length with zero.
 *
 * Can also be used as a `method`:
 *
 *     mylist->empty()
 */
export function empty(denops: Denops, expr: unknown): Promise<unknown>;
export function empty(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("empty", ...args);
}

/**
 * Return all of environment variables as dictionary. You can
 * check if an environment variable exists like this:
 *
 *     :echo has_key(environ(), 'HOME')
 *
 * Note that the variable name may be CamelCase; to ignore case
 * use this:
 *
 *     :echo index(keys(environ()), 'HOME', 0, 1) != -1
 */
export function environ(denops: Denops): Promise<unknown>;
export function environ(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("environ", ...args);
}

/**
 * Escape the characters in **{chars}** that occur in **{string}** with a
 * backslash.  Example:
 *
 *     :echo escape('c:\program files\vim', ' \')
 *
 * results in:
 *
 *     c:\\program\ files\\vim
 *
 * Also see `shellescape()` and `fnameescape()`.
 *
 * Can also be used as a `method`:
 *
 *     GetText()->escape(' \')
 */
export function escape(
  denops: Denops,
  string: unknown,
  chars: unknown,
): Promise<unknown>;
export function escape(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("escape", ...args);
}

/**
 * Evaluate **{string}** and return the result.  Especially useful to
 * turn the result of `string()` back into the original value.
 * This works for Numbers, Floats, Strings, Blobs and composites
 * of them.  Also works for `Funcref`s that refer to existing
 * functions.
 *
 * Can also be used as a `method`:
 *
 *     argv->join()->eval()
 */
export function eval_(denops: Denops, string: unknown): Promise<unknown>;
export function eval_(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("eval_", ...args);
}

/**
 * Returns 1 when inside an event handler.  That is that Vim got
 * interrupted while waiting for the user to type a character,
 * e.g., when dropping a file on Vim.  This means interactive
 * commands cannot be used.  Otherwise zero is returned.
 */
export function eventhandler(denops: Denops): Promise<unknown>;
export function eventhandler(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("eventhandler", ...args);
}

/**
 * This function checks if an executable with the name **{expr}**
 * exists.  **{expr}** must be the name of the program without any
 * arguments.
 * executable() uses the value of $PATH and/or the normal
 * searchpath for programs.
 * On MS-Windows the ".exe", ".bat", etc. can optionally be
 * included.  Then the extensions in $PATHEXT are tried.  Thus if
 * "foo.exe" does not exist, "foo.exe.bat" can be found.  If
 * $PATHEXT is not set then ".com;.exe;.bat;.cmd" is used.  A dot
 * by itself can be used in $PATHEXT to try using the name
 * without an extension.  When 'shell' looks like a Unix shell,
 * then the name is also tried without adding an extension.
 * On MS-Windows it only checks if the file exists and is not a
 * directory, not if it's really executable.
 * On MS-Windows an executable in the same directory as Vim is
 * normally found.  Since this directory is added to $PATH it
 * should also work to execute it `win32-PATH`.  This can be
 * disabled by setting the $NoDefaultCurrentDirectoryInExePath
 * environment variable.
 * The result is a Number:
 *         1       exists
 *         0       does not exist
 *         -1      not implemented on this system
 * `exepath()` can be used to get the full path of an executable.
 *
 * Can also be used as a `method`:
 *
 *     GetCommand()->executable()
 */
export function executable(denops: Denops, expr: unknown): Promise<unknown>;
export function executable(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("executable", ...args);
}

/**
 * Execute an Ex command or commands and return the output as a
 * string.
 * **{command}** can be a string or a List.  In case of a List the
 * lines are executed one by one.
 * This is equivalent to:
 *
 *     redir => var
 *     {command}
 *     redir END
 *
 * The optional **{silent}** argument can have these values:
 *         ""              no `:silent` used
 *         "silent"        `:silent` used
 *         "silent!"       `:silent!` used
 * The default is "silent".  Note that with "silent!", unlike
 * `:redir`, error messages are dropped.  When using an external
 * command the screen may be messed up, use `system()` instead.
 *
 * It is not possible to use `:redir` anywhere in **{command}**.
 *
 * To get a list of lines use `split()` on the result:
 *
 *     execute('args')->split("\n")
 *
 * To execute a command in another window than the current one
 * use `win_execute()`.
 *
 * When used recursively the output of the recursive call is not
 * included in the output of the higher level call.
 *
 * Can also be used as a `method`:
 *
 *     GetCommand()->execute()
 */
export function execute(
  denops: Denops,
  command: unknown,
  silent?: unknown,
): Promise<unknown>;
export function execute(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("execute", ...args);
}

/**
 * If **{expr}** is an executable and is either an absolute path, a
 * relative path or found in $PATH, return the full path.
 * Note that the current directory is used when **{expr}** starts
 * with "./", which may be a problem for Vim:
 *
 *     echo exepath(v:progpath)
 *
 * If **{expr}** cannot be found in $PATH or is not executable then
 * an empty string is returned.
 *
 * Can also be used as a `method`:
 *
 *     GetCommand()->exepath()
 */
export function exepath(denops: Denops, expr: unknown): Promise<unknown>;
export function exepath(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("exepath", ...args);
}

/**
 * Return the exponential of **{expr}** as a `Float` in the range
 * [0, inf].
 * **{expr}** must evaluate to a `Float` or a `Number`.
 * Returns 0.0 if **{expr}** is not a `Float` or a `Number`.
 * Examples:
 *
 *     :echo exp(2)
 *
 *         7.389056
 *
 *     :echo exp(-1)
 *
 *         0.367879
 *
 * Can also be used as a `method`:
 *
 *     Compute()->exp()
 *
 * *only available when compiled with the `+float` feature*
 */
export function exp(denops: Denops, expr: unknown): Promise<unknown>;
export function exp(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("exp", ...args);
}

/**
 * Expand wildcards and the following special keywords in
 * **{string}**.  'wildignorecase' applies.
 *
 * If **{list}** is given and it is `TRUE`, a List will be returned.
 * Otherwise the result is a String and when there are several
 * matches, they are separated by `<NL>` characters.  [Note: in
 * version 5.0 a space was used, which caused problems when a
 * file name contains a space]
 *
 * If the expansion fails, the result is an empty string.  A name
 * for a non-existing file is not included, unless **{string}** does
 * not start with '%', '#' or '<', see below.
 *
 * When **{string}** starts with '%', '#' or '<', the expansion is
 * done like for the `cmdline-special` variables with their
 * associated modifiers.  Here is a short overview:
 *
 *         %               current file name
 *         #               alternate file name
 *         #n              alternate file name n
 *         `<cfile>`         file name under the cursor
 *         `<afile>`         autocmd file name
 *         `<abuf>`          autocmd buffer number (as a String!)
 *         `<amatch>`        autocmd matched name
 *         `<cexpr>`         C expression under the cursor
 *         `<sfile>`         sourced script file or function name
 *         `<slnum>`         sourced script line number or function
 *                         line number
 *         `<sflnum>`        script file line number, also when in
 *                         a function
 *         `<SID>`           `"<SNR>123_"`  where "123" is the
 *                         current script ID  `<SID>`
 *         `<script>`        sourced script file, or script file
 *                         where the current function was defined
 *         `<stack>`         call stack
 *         `<cword>`         word under the cursor
 *         `<cWORD>`         WORD under the cursor
 *         `<client>`        the **{clientid}** of the last received
 *                         message `server2client()`
 * Modifiers:
 *         :p              expand to full path
 *         :h              head (last path component removed)
 *         :t              tail (last path component only)
 *         :r              root (one extension removed)
 *         :e              extension only
 *
 * Example:
 *
 *     :let &tags = expand("%:p:h") .. "/tags"
 *
 * Note that when expanding a string that starts with '%', '#' or
 * '<', any following text is ignored.  This does NOT work:
 *
 *     :let doesntwork = expand("%:h.bak")
 *
 * Use this:
 *
 *     :let doeswork = expand("%:h") .. ".bak"
 *
 * Also note that expanding `"<cfile>"` and others only returns the
 * referenced file name without further expansion.  If `"<cfile>"`
 * is `"~/.cshrc"`, you need to do another expand() to have the
 * `"~/"` expanded into the path of the home directory:
 *
 *     :echo expand(expand("<cfile>"))
 *
 * There cannot be white space between the variables and the
 * following modifier.  The `fnamemodify()` function can be used
 * to modify normal file names.
 *
 * When using '%' or '#', and the current or alternate file name
 * is not defined, an empty string is used.  Using "%:p" in a
 * buffer with no name, results in the current directory, with a
 * '/' added.
 * When 'verbose' is set then expanding '%', '#' and `<>` items
 * will result in an error message if the argument cannot be
 * expanded.
 *
 * When **{string}** does not start with '%', '#' or '<', it is
 * expanded like a file name is expanded on the command line.
 * 'suffixes' and 'wildignore' are used, unless the optional
 * **{nosuf}** argument is given and it is `TRUE`.
 * Names for non-existing files are included.  The "**" item can
 * be used to search in a directory tree.  For example, to find
 * all "README" files in the current directory and below:
 *
 *     :echo expand("** /README")
 *
 * expand() can also be used to expand variables and environment
 * variables that are only known in a shell.  But this can be
 * slow, because a shell may be used to do the expansion.  See
 * `expr-env-expand`.
 * The expanded variable is still handled like a list of file
 * names.  When an environment variable cannot be expanded, it is
 * left unchanged.  Thus ":echo expand('$FOOBAR')" results in
 * "$FOOBAR".
 *
 * See `glob()` for finding existing files.  See `system()` for
 * getting the raw output of an external command.
 *
 * Can also be used as a `method`:
 *
 *     Getpattern()->expand()
 */
export function expand(
  denops: Denops,
  string: unknown,
  nosuf?: unknown,
  list?: unknown,
): Promise<unknown>;
export function expand(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("expand", ...args);
}

/**
 * Expand special items in String **{string}** like what is done for
 * an Ex command such as `:edit`.  This expands special keywords,
 * like with `expand()`, and environment variables, anywhere in
 * **{string}**.  `"~user"` and `"~/path"` are only expanded at the
 * start.
 *
 * The following items are supported in the **{options}** Dict
 * argument:
 *     errmsg      If set to TRUE, error messages are displayed
 *                 if an error is encountered during expansion.
 *                 By default, error messages are not displayed.
 *
 * Returns the expanded string.  If an error is encountered
 * during expansion, the unmodified **{string}** is returned.
 *
 * Example:
 *
 *     :echo expandcmd('make %<.o')
 *     make /path/runtime/doc/builtin.o
 *     :echo expandcmd('make %<.o', {'errmsg': v:true})
 *
 * Can also be used as a `method`:
 *
 *     GetCommand()->expandcmd()
 */
export function expandcmd(
  denops: Denops,
  string: unknown,
  options?: unknown,
): Promise<unknown>;
export function expandcmd(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("expandcmd", ...args);
}

/**
 * **{expr1}** and **{expr2}** must be both `Lists` or both
 * `Dictionaries`.
 *
 * If they are `Lists`: Append **{expr2}** to **{expr1}**.
 * If **{expr3}** is given insert the items of **{expr2}** before the
 * item with index **{expr3}** in **{expr1}**.  When **{expr3}** is zero
 * insert before the first item.  When **{expr3}** is equal to
 * len(**{expr1}**) then **{expr2}** is appended.
 * Examples:
 *
 *     :echo sort(extend(mylist, [7, 5]))
 *     :call extend(mylist, [2, 3], 1)
 *
 * When **{expr1}** is the same List as **{expr2}** then the number of
 * items copied is equal to the original length of the List.
 * E.g., when **{expr3}** is 1 you get N new copies of the first item
 * (where N is the original length of the List).
 * Use `add()` to concatenate one item to a list.  To concatenate
 * two lists into a new list use the + operator:
 *
 *     :let newlist = [1, 2, 3] + [4, 5]
 *
 * If they are `Dictionaries`:
 * Add all entries from **{expr2}** to **{expr1}**.
 * If a key exists in both **{expr1}** and **{expr2}** then **{expr3}** is
 * used to decide what to do:
 * **{expr3}** = "keep": keep the value of **{expr1}**
 * **{expr3}** = "force": use the value of **{expr2}**
 * **{expr3}** = "error": give an error message
 * When **{expr3}** is omitted then "force" is assumed.
 *
 * **{expr1}** is changed when **{expr2}** is not empty.  If necessary
 * make a copy of **{expr1}** first.
 * **{expr2}** remains unchanged.
 * When **{expr1}** is locked and **{expr2}** is not empty the operation
 * fails.
 * Returns **{expr1}**.  Returns 0 on error.
 *
 * Can also be used as a `method`:
 *
 *     mylist->extend(otherlist)
 */
export function extend(
  denops: Denops,
  expr1: unknown,
  expr2: unknown,
  expr3?: unknown,
): Promise<unknown>;
export function extend(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("extend", ...args);
}

/**
 * Characters in **{string}** are queued for processing as if they
 * come from a mapping or were typed by the user.
 *
 * By default the string is added to the end of the typeahead
 * buffer, thus if a mapping is still being executed the
 * characters come after them.  Use the 'i' flag to insert before
 * other characters, they will be executed next, before any
 * characters from a mapping.
 *
 * The function does not wait for processing of keys contained in
 * **{string}**.
 *
 * To include special keys into **{string}**, use double-quotes
 * and "\..." notation `expr-quote`. For example,
 * feedkeys(`"\<CR>"`) simulates pressing of the `<Enter>` key. But
 * feedkeys('\<CR>') pushes 5 characters.
 * A special code that might be useful is `<Ignore>`, it exits the
 * wait for a character without doing anything.
 *
 * **{mode}** is a String, which can contain these character flags:
 * 'm'     Remap keys. This is default.  If **{mode}** is absent,
 *         keys are remapped.
 * 'n'     Do not remap keys.
 * 't'     Handle keys as if typed; otherwise they are handled as
 *         if coming from a mapping.  This matters for undo,
 *         opening folds, etc.
 * 'L'     Lowlevel input.  Only works for Unix or when using the
 *         GUI. Keys are used as if they were coming from the
 *         terminal.  Other flags are not used.
 *         When a CTRL-C interrupts and 't' is included it sets
 *         the internal "got_int" flag.
 * 'i'     Insert the string instead of appending (see above).
 * 'x'     Execute commands until typeahead is empty.  This is
 *         similar to using ":normal!".  You can call feedkeys()
 *         several times without 'x' and then one time with 'x'
 *         (possibly with an empty **{string}**) to execute all the
 *         typeahead.  Note that when Vim ends in Insert mode it
 *         will behave as if `<Esc>` is typed, to avoid getting
 *         stuck, waiting for a character to be typed before the
 *         script continues.
 *         Note that if you manage to call feedkeys() while
 *         executing commands, thus calling it recursively, then
 *         all typeahead will be consumed by the last call.
 * 'c'     Remove any script context when executing, so that
 *         legacy script syntax applies, "s:var" does not work,
 *         etc.  Note that if the string being fed sets a script
 *         context this still applies.
 * '!'     When used with 'x' will not end Insert mode. Can be
 *         used in a test when a timer is set to exit Insert mode
 *         a little later.  Useful for testing CursorHoldI.
 *
 * Return value is always 0.
 *
 * Can also be used as a `method`:
 *
 *     GetInput()->feedkeys()
 */
export function feedkeys(
  denops: Denops,
  string: unknown,
  mode?: unknown,
): Promise<unknown>;
export function feedkeys(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("feedkeys", ...args);
}

/**
 * The result is a Number, which is `TRUE` when a file with the
 * name **{file}** exists, and can be read.  If **{file}** doesn't exist,
 * or is a directory, the result is `FALSE`.  **{file}** is any
 * expression, which is used as a String.
 * If you don't care about the file being readable you can use
 * `glob()`.
 * **{file}** is used as-is, you may want to expand wildcards first:
 *
 *     echo filereadable('~/.vimrc')
 *     0
 *     echo filereadable(expand('~/.vimrc'))
 *     1
 *
 * Can also be used as a `method`:
 *
 *     GetName()->filereadable()
 *
 * Obsolete name: file_readable().
 */
export function filereadable(denops: Denops, file: unknown): Promise<unknown>;
export function filereadable(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("filereadable", ...args);
}

/**
 * The result is a Number, which is 1 when a file with the
 * name **{file}** exists, and can be written.  If **{file}** doesn't
 * exist, or is not writable, the result is 0.  If **{file}** is a
 * directory, and we can write to it, the result is 2.
 *
 * Can also be used as a `method`:
 *
 *     GetName()->filewritable()
 */
export function filewritable(denops: Denops, file: unknown): Promise<unknown>;
export function filewritable(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("filewritable", ...args);
}

/**
 * **{expr1}** must be a `List`, `String`, `Blob` or `Dictionary`.
 * For each item in **{expr1}** evaluate **{expr2}** and when the result
 * is zero or false remove the item from the `List` or
 * `Dictionary`.  Similarly for each byte in a `Blob` and each
 * character in a `String`.
 *
 * **{expr2}** must be a `string` or `Funcref`.
 *
 * If **{expr2}** is a `string`, inside **{expr2}** `v:val` has the value
 * of the current item.  For a `Dictionary` `v:key` has the key
 * of the current item and for a `List` `v:key` has the index of
 * the current item.  For a `Blob` `v:key` has the index of the
 * current byte. For a `String` `v:key` has the index of the
 * current character.
 * Examples:
 *
 *     call filter(mylist, 'v:val !~ "OLD"')
 *
 * Removes the items where "OLD" appears.
 *
 *     call filter(mydict, 'v:key >= 8')
 *
 * Removes the items with a key below 8.
 *
 *     call filter(var, 0)
 *
 * Removes all the items, thus clears the `List` or `Dictionary`.
 *
 * Note that **{expr2}** is the result of expression and is then
 * used as an expression again.  Often it is good to use a
 * `literal-string` to avoid having to double backslashes.
 *
 * If **{expr2}** is a `Funcref` it must take two arguments:
 *         1. the key or the index of the current item.
 *         2. the value of the current item.
 * The function must return `TRUE` if the item should be kept.
 * Example that keeps the odd items of a list:
 *
 *     func Odd(idx, val)
 *       return a:idx % 2 == 1
 *     endfunc
 *     call filter(mylist, function('Odd'))
 *
 * It is shorter when using a `lambda`.  In `Vim9` syntax:
 *
 *     call filter(myList, (idx, val) => idx * val <= 42)
 *
 * In legacy script syntax:
 *
 *     call filter(myList, {idx, val -> idx * val <= 42})
 *
 * If you do not use "val" you can leave it out:
 *
 *     call filter(myList, {idx -> idx % 2 == 1})
 *
 * In `Vim9` script the result must be true, false, zero or one.
 * Other values will result in a type error.
 *
 * For a `List` and a `Dictionary` the operation is done
 * in-place.  If you want it to remain unmodified make a copy
 * first:
 *
 *     :let l = filter(copy(mylist), 'v:val =~ "KEEP"')
 *
 * Returns **{expr1}**, the `List` or `Dictionary` that was filtered,
 * or a new `Blob` or `String`.
 * When an error is encountered while evaluating **{expr2}** no
 * further items in **{expr1}** are processed.
 * When **{expr2}** is a Funcref errors inside a function are ignored,
 * unless it was defined with the "abort" flag.
 *
 * Can also be used as a `method`:
 *
 *     mylist->filter(expr2)
 */
export function filter(
  denops: Denops,
  expr1: unknown,
  expr2: unknown,
): Promise<unknown>;
export function filter(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("filter", ...args);
}

/**
 * Find directory **{name}** in **{path}**.  Supports both downwards and
 * upwards recursive directory searches.  See `file-searching`
 * for the syntax of **{path}**.
 *
 * Returns the path of the first found match.  When the found
 * directory is below the current directory a relative path is
 * returned.  Otherwise a full path is returned.
 * If **{path}** is omitted or empty then 'path' is used.
 *
 * If the optional **{count}** is given, find **{count}**'s occurrence of
 * **{name}** in **{path}** instead of the first one.
 * When **{count}** is negative return all the matches in a `List`.
 *
 * Returns an empty string if the directory is not found.
 *
 * This is quite similar to the ex-command `:find`.
 *
 * Can also be used as a `method`:
 *
 *     GetName()->finddir()
 */
export function finddir(
  denops: Denops,
  name: unknown,
  path?: unknown,
  count?: unknown,
): Promise<unknown>;
export function finddir(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("finddir", ...args);
}

/**
 * Just like `finddir()`, but find a file instead of a directory.
 * Uses 'suffixesadd'.
 * Example:
 *
 *     :echo findfile("tags.vim", ".;")
 *
 * Searches from the directory of the current file upwards until
 * it finds the file "tags.vim".
 *
 * Can also be used as a `method`:
 *
 *     GetName()->findfile()
 */
export function findfile(
  denops: Denops,
  name: unknown,
  path?: unknown,
  count?: unknown,
): Promise<unknown>;
export function findfile(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("findfile", ...args);
}

/**
 * Flatten **{list}** up to **{maxdepth}** levels.  Without **{maxdepth}**
 * the result is a `List` without nesting, as if **{maxdepth}** is
 * a very large number.
 * The **{list}** is changed in place, use `flattennew()` if you do
 * not want that.
 * In Vim9 script flatten() cannot be used, you must always use
 * `flattennew()`.
 *
 * **{maxdepth}** means how deep in nested lists changes are made.
 * **{list}** is not modified when **{maxdepth}** is 0.
 * **{maxdepth}** must be positive number.
 *
 * If there is an error the number zero is returned.
 *
 * Example:
 *
 *     :echo flatten([1, [2, [3, 4]], 5])
 *
 *         [1, 2, 3, 4, 5]
 *
 *     :echo flatten([1, [2, [3, 4]], 5], 1)
 *
 *         [1, 2, [3, 4], 5]
 *
 * Can also be used as a `method`:
 *
 *     mylist->flatten()
 */
export function flatten(
  denops: Denops,
  list: unknown,
  maxdepth?: unknown,
): Promise<unknown>;
export function flatten(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("flatten", ...args);
}

/**
 * Convert **{expr}** to a Number by omitting the part after the
 * decimal point.
 * **{expr}** must evaluate to a `Float` or a Number.
 * Returns 0 if **{expr}** is not a `Float` or a `Number`.
 * When the value of **{expr}** is out of range for a `Number` the
 * result is truncated to 0x7fffffff or -0x7fffffff (or when
 * 64-bit Number support is enabled, 0x7fffffffffffffff or
 * -0x7fffffffffffffff).  NaN results in -0x80000000 (or when
 * 64-bit Number support is enabled, -0x8000000000000000).
 * Examples:
 *
 *     echo float2nr(3.95)
 *
 *         3
 *
 *     echo float2nr(-23.45)
 *
 *         -23
 *
 *     echo float2nr(1.0e100)
 *
 *         2147483647  (or 9223372036854775807)
 *
 *     echo float2nr(-1.0e150)
 *
 *         -2147483647 (or -9223372036854775807)
 *
 *     echo float2nr(1.0e-100)
 *
 *         0
 *
 * Can also be used as a `method`:
 *
 *     Compute()->float2nr()
 *
 * *only available when compiled with the `+float` feature*
 */
export function float2nr(denops: Denops, expr: unknown): Promise<unknown>;
export function float2nr(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("float2nr", ...args);
}

/**
 * Return the largest integral value less than or equal to
 * **{expr}** as a `Float` (round down).
 * **{expr}** must evaluate to a `Float` or a `Number`.
 * Returns 0.0 if **{expr}** is not a `Float` or a `Number`.
 * Examples:
 *
 *     echo floor(1.856)
 *
 *         1.0
 *
 *     echo floor(-5.456)
 *
 *         -6.0
 *
 *     echo floor(4.0)
 *
 *         4.0
 *
 * Can also be used as a `method`:
 *
 *     Compute()->floor()
 *
 * *only available when compiled with the `+float` feature*
 */
export function floor(denops: Denops, expr: unknown): Promise<unknown>;
export function floor(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("floor", ...args);
}

/**
 * Return the remainder of **{expr1}** / **{expr2}**, even if the
 * division is not representable.  Returns **{expr1}** - i * **{expr2}**
 * for some integer i such that if **{expr2}** is non-zero, the
 * result has the same sign as **{expr1}** and magnitude less than
 * the magnitude of **{expr2}**.  If **{expr2}** is zero, the value
 * returned is zero.  The value returned is a `Float`.
 * **{expr1}** and **{expr2}** must evaluate to a `Float` or a `Number`.
 * Returns 0.0 if **{expr1}** or **{expr2}** is not a `Float` or a
 * `Number`.
 * Examples:
 *
 *     :echo fmod(12.33, 1.22)
 *
 *         0.13
 *
 *     :echo fmod(-12.33, 1.22)
 *
 *         -0.13
 *
 * Can also be used as a `method`:
 *
 *     Compute()->fmod(1.22)
 *
 * *only available when compiled with `+float` feature*
 */
export function fmod(
  denops: Denops,
  expr1: unknown,
  expr2: unknown,
): Promise<unknown>;
export function fmod(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("fmod", ...args);
}

/**
 * Escape **{string}** for use as file name command argument.  All
 * characters that have a special meaning, such as '%' and '|'
 * are escaped with a backslash.
 * For most systems the characters escaped are
 * ``" \t\n*?[{`$\\%#'\"|!<"``.  For systems where a backslash
 * appears in a filename, it depends on the value of 'isfname'.
 * A leading '+' and '>' is also escaped (special after `:edit`
 * and `:write`).  And a "-" by itself (special after `:cd`).
 * Returns an empty string on error.
 * Example:
 *
 *     :let fname = '+some str%nge|name'
 *     :exe "edit " .. fnameescape(fname)
 *
 * results in executing:
 *
 *     edit \+some\ str\%nge\|name
 *
 * Can also be used as a `method`:
 *
 *     GetName()->fnameescape()
 */
export function fnameescape(denops: Denops, string: unknown): Promise<unknown>;
export function fnameescape(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("fnameescape", ...args);
}

/**
 * Modify file name **{fname}** according to **{mods}**.  **{mods}** is a
 * string of characters like it is used for file names on the
 * command line.  See `filename-modifiers`.
 * Example:
 *
 *     :echo fnamemodify("main.c", ":p:h")
 *
 * results in:
 *
 *     /home/user/vim/vim/src
 *
 * If **{mods}** is empty or an unsupported modifier is used then
 * **{fname}** is returned.
 * When **{fname}** is empty then with **{mods}** ":h" returns ".", so
 * that `:cd` can be used with it.  This is different from
 * expand('%:h') without a buffer name, which returns an empty
 * string.
 * Note: Environment variables don't work in **{fname}**, use
 * `expand()` first then.
 *
 * Can also be used as a `method`:
 *
 *     GetName()->fnamemodify(':p:h')
 */
export function fnamemodify(
  denops: Denops,
  fname: unknown,
  mods: unknown,
): Promise<unknown>;
export function fnamemodify(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("fnamemodify", ...args);
}

/**
 * The result is a Number.  If the line **{lnum}** is in a closed
 * fold, the result is the number of the first line in that fold.
 * If the line **{lnum}** is not in a closed fold, -1 is returned.
 * **{lnum}** is used like with `getline()`.  Thus "." is the current
 * line, "'m" mark m, etc.
 *
 * Can also be used as a `method`:
 *
 *     GetLnum()->foldclosed()
 */
export function foldclosed(denops: Denops, lnum: unknown): Promise<unknown>;
export function foldclosed(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("foldclosed", ...args);
}

/**
 * The result is a Number.  If the line **{lnum}** is in a closed
 * fold, the result is the number of the last line in that fold.
 * If the line **{lnum}** is not in a closed fold, -1 is returned.
 * **{lnum}** is used like with `getline()`.  Thus "." is the current
 * line, "'m" mark m, etc.
 *
 * Can also be used as a `method`:
 *
 *     GetLnum()->foldclosedend()
 */
export function foldclosedend(denops: Denops, lnum: unknown): Promise<unknown>;
export function foldclosedend(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("foldclosedend", ...args);
}

/**
 * The result is a Number, which is the foldlevel of line **{lnum}**
 * in the current buffer.  For nested folds the deepest level is
 * returned.  If there is no fold at line **{lnum}**, zero is
 * returned.  It doesn't matter if the folds are open or closed.
 * When used while updating folds (from 'foldexpr') -1 is
 * returned for lines where folds are still to be updated and the
 * foldlevel is unknown.  As a special case the level of the
 * previous line is usually available.
 * **{lnum}** is used like with `getline()`.  Thus "." is the current
 * line, "'m" mark m, etc.
 *
 * Can also be used as a `method`:
 *
 *     GetLnum()->foldlevel()
 */
export function foldlevel(denops: Denops, lnum: unknown): Promise<unknown>;
export function foldlevel(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("foldlevel", ...args);
}

/**
 * Returns a String, to be displayed for a closed fold.  This is
 * the default function used for the 'foldtext' option and should
 * only be called from evaluating 'foldtext'.  It uses the
 * `v:foldstart`, `v:foldend` and `v:folddashes` variables.
 * The returned string looks like this:
 *
 *     +-- 45 lines: abcdef
 *
 * The number of leading dashes depends on the foldlevel.  The
 * "45" is the number of lines in the fold.  "abcdef" is the text
 * in the first non-blank line of the fold.  Leading white space,
 * "//" or "/*" and the text from the 'foldmarker' and
 * 'commentstring' options is removed.
 * When used to draw the actual foldtext, the rest of the line
 * will be filled with the fold char from the 'fillchars'
 * setting.
 * Returns an empty string when there is no fold.
 * *not available when compiled without the `+folding` feature*
 */
export function foldtext(denops: Denops): Promise<unknown>;
export function foldtext(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("foldtext", ...args);
}

/**
 * Returns the text that is displayed for the closed fold at line
 * **{lnum}**.  Evaluates 'foldtext' in the appropriate context.
 * When there is no closed fold at **{lnum}** an empty string is
 * returned.
 * **{lnum}** is used like with `getline()`.  Thus "." is the current
 * line, "'m" mark m, etc.
 * Useful when exporting folded text, e.g., to HTML.
 * *not available when compiled without the `+folding` feature*
 *
 * Can also be used as a `method`:
 *
 *     GetLnum()->foldtextresult()
 */
export function foldtextresult(denops: Denops, lnum: unknown): Promise<unknown>;
export function foldtextresult(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("foldtextresult", ...args);
}

/**
 * Get the full command name from a short abbreviated command
 * name; see `20.2` for details on command abbreviations.
 *
 * The string argument **{name}** may start with a `:` and can
 * include a [range], these are skipped and not returned.
 * Returns an empty string if a command doesn't exist or if it's
 * ambiguous (for user-defined commands).
 *
 * For example `fullcommand('s')`, `fullcommand('sub')`,
 * `fullcommand(':%substitute')` all return "substitute".
 *
 * Can also be used as a `method`:
 *
 *     GetName()->fullcommand()
 */
export function fullcommand(denops: Denops, name: unknown): Promise<unknown>;
export function fullcommand(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("fullcommand", ...args);
}

/**
 * Just like `function()`, but the returned Funcref will lookup
 * the function by reference, not by name.  This matters when the
 * function **{name}** is redefined later.
 *
 * Unlike `function()`, **{name}** must be an existing user function.
 * It only works for an autoloaded function if it has already
 * been loaded (to avoid mistakenly loading the autoload script
 * when only intending to use the function name, use `function()`
 * instead). **{name}** cannot be a builtin function.
 * Returns 0 on error.
 *
 * Can also be used as a `method`:
 *
 *     GetFuncname()->funcref([arg])
 */
export function funcref(
  denops: Denops,
  name: unknown,
  arglist?: unknown,
  dict?: unknown,
): Promise<unknown>;
export function funcref(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("funcref", ...args);
}

/**
 * Return a `Funcref` variable that refers to function **{name}**.
 * **{name}** can be the name of a user defined function or an
 * internal function.
 *
 * **{name}** can also be a Funcref or a partial.  When it is a
 * partial the dict stored in it will be used and the **{dict}**
 * argument is not allowed. E.g.:
 *
 *     let FuncWithArg = function(dict.Func, [arg])
 *     let Broken = function(dict.Func, [arg], dict)
 *
 * When using the Funcref the function will be found by **{name}**,
 * also when it was redefined later.  Use `funcref()` to keep the
 * same function.
 *
 * When **{arglist}** or **{dict}** is present this creates a partial.
 * That means the argument list and/or the dictionary is stored in
 * the Funcref and will be used when the Funcref is called.
 *
 * The arguments are passed to the function in front of other
 * arguments, but after any argument from `method`.  Example:
 *
 *     func Callback(arg1, arg2, name)
 *     ...
 *     let Partial = function('Callback', ['one', 'two'])
 *     ...
 *     call Partial('name')
 *
 * Invokes the function as with:
 *
 *     call Callback('one', 'two', 'name')
 *
 * With a `method`:
 *
 *     func Callback(one, two, three)
 *     ...
 *     let Partial = function('Callback', ['two'])
 *     ...
 *     eval 'one'->Partial('three')
 *
 * Invokes the function as with:
 *
 *     call Callback('one', 'two', 'three')
 *
 * The function() call can be nested to add more arguments to the
 * Funcref.  The extra arguments are appended to the list of
 * arguments.  Example:
 *
 *     func Callback(arg1, arg2, name)
 *     "...
 *     let Func = function('Callback', ['one'])
 *     let Func2 = function(Func, ['two'])
 *     "...
 *     call Func2('name')
 *
 * Invokes the function as with:
 *
 *     call Callback('one', 'two', 'name')
 *
 * The Dictionary is only useful when calling a "dict" function.
 * In that case the **{dict}** is passed in as "self". Example:
 *
 *     function Callback() dict
 *        echo "called for " .. self.name
 *     endfunction
 *     "...
 *     let context = {"name": "example"}
 *     let Func = function('Callback', context)
 *     "...
 *     call Func()     " will echo: called for example
 *
 * The use of function() is not needed when there are no extra
 * arguments, these two are equivalent, if Callback() is defined
 * as context.Callback():
 *
 *     let Func = function('Callback', context)
 *     let Func = context.Callback
 *
 * The argument list and the Dictionary can be combined:
 *
 *     function Callback(arg1, count) dict
 *     "...
 *     let context = {"name": "example"}
 *     let Func = function('Callback', ['one'], context)
 *     "...
 *     call Func(500)
 *
 * Invokes the function as with:
 *
 *     call context.Callback('one', 500)
 *
 * Returns 0 on error.
 *
 * Can also be used as a `method`:
 *
 *     GetFuncname()->function([arg])
 */
export function function_(
  denops: Denops,
  name: unknown,
  arglist?: unknown,
  dict?: unknown,
): Promise<unknown>;
export function function_(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("function_", ...args);
}

/**
 * Cleanup unused `Lists`, `Dictionaries`, `Channels` and `Jobs`
 * that have circular references.
 *
 * There is hardly ever a need to invoke this function, as it is
 * automatically done when Vim runs out of memory or is waiting
 * for the user to press a key after 'updatetime'.  Items without
 * circular references are always freed when they become unused.
 * This is useful if you have deleted a very big `List` and/or
 * `Dictionary` with circular references in a script that runs
 * for a long time.
 *
 * When the optional **{atexit}** argument is one, garbage
 * collection will also be done when exiting Vim, if it wasn't
 * done before.  This is useful when checking for memory leaks.
 *
 * The garbage collection is not done immediately but only when
 * it's safe to perform.  This is when waiting for the user to
 * type a character.  To force garbage collection immediately use
 * `test_garbagecollect_now()`.
 */
export function garbagecollect(
  denops: Denops,
  atexit?: unknown,
): Promise<unknown>;
export function garbagecollect(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("garbagecollect", ...args);
}

/**
 * Get item **{idx}** from `List` **{list}**.  When this item is not
 * available return **{default}**.  Return zero when **{default}** is
 * omitted.
 * Preferably used as a `method`:
 *
 *     mylist->get(idx)
 */
export function get(
  denops: Denops,
  list: unknown,
  idx: unknown,
  defaultValue?: unknown,
): Promise<unknown>;
export function get(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("get", ...args);
}

/**
 * Get information about buffers as a List of Dictionaries.
 *
 * Without an argument information about all the buffers is
 * returned.
 *
 * When the argument is a `Dictionary` only the buffers matching
 * the specified criteria are returned.  The following keys can
 * be specified in **{dict}**:
 *         buflisted       include only listed buffers.
 *         bufloaded       include only loaded buffers.
 *         bufmodified     include only modified buffers.
 *
 * Otherwise, **{buf}** specifies a particular buffer to return
 * information for.  For the use of **{buf}**, see `bufname()`
 * above.  If the buffer is found the returned List has one item.
 * Otherwise the result is an empty list.
 *
 * Each returned List item is a dictionary with the following
 * entries:
 *         bufnr           Buffer number.
 *         changed         TRUE if the buffer is modified.
 *         changedtick     Number of changes made to the buffer.
 *         hidden          TRUE if the buffer is hidden.
 *         lastused        Timestamp in seconds, like
 *                         `localtime()`, when the buffer was
 *                         last used.
 *                         *only with the `+viminfo` feature*
 *         listed          TRUE if the buffer is listed.
 *         lnum            Line number used for the buffer when
 *                         opened in the current window.
 *                         Only valid if the buffer has been
 *                         displayed in the window in the past.
 *                         If you want the line number of the
 *                         last known cursor position in a given
 *                         window, use `line()`:
 *
 *                             :echo line('.', {winid})
 *
 *         linecount       Number of lines in the buffer (only
 *                         valid when loaded)
 *         loaded          TRUE if the buffer is loaded.
 *         name            Full path to the file in the buffer.
 *         signs           List of signs placed in the buffer.
 *                         Each list item is a dictionary with
 *                         the following fields:
 *                             id    sign identifier
 *                             lnum  line number
 *                             name  sign name
 *         variables       A reference to the dictionary with
 *                         buffer-local variables.
 *         windows         List of `window-ID`s that display this
 *                         buffer
 *         popups          List of popup `window-ID`s that
 *                         display this buffer
 *
 * Examples:
 *
 *     for buf in getbufinfo()
 *         echo buf.name
 *     endfor
 *     for buf in getbufinfo({'buflisted':1})
 *         if buf.changed
 *             ....
 *         endif
 *     endfor
 *
 * To get buffer-local options use:
 *
 *     getbufvar({bufnr}, '&option_name')
 *
 * Can also be used as a `method`:
 *
 *     GetBufnr()->getbufinfo()
 */
export function getbufinfo(denops: Denops, buf?: unknown): Promise<unknown>;
export function getbufinfo(denops: Denops, dict?: unknown): Promise<unknown>;
export function getbufinfo(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getbufinfo", ...args);
}

/**
 * The result is the value of option or local buffer variable
 * **{varname}** in buffer **{buf}**.  Note that the name without "b:"
 * must be used.
 * The **{varname}** argument is a string.
 * When **{varname}** is empty returns a `Dictionary` with all the
 * buffer-local variables.
 * When **{varname}** is equal to "&" returns a `Dictionary` with all
 * the buffer-local options.
 * Otherwise, when **{varname}** starts with "&" returns the value of
 * a buffer-local option.
 * This also works for a global or buffer-local option, but it
 * doesn't work for a global variable, window-local variable or
 * window-local option.
 * For the use of **{buf}**, see `bufname()` above.
 * When the buffer or variable doesn't exist **{def}** or an empty
 * string is returned, there is no error message.
 * Examples:
 *
 *     :let bufmodified = getbufvar(1, "&mod")
 *     :echo "todo myvar = " .. getbufvar("todo", "myvar")
 *
 * Can also be used as a `method`:
 *
 *     GetBufnr()->getbufvar(varname)
 */
export function getbufvar(
  denops: Denops,
  buf: unknown,
  varname: unknown,
  def?: unknown,
): Promise<unknown>;
export function getbufvar(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getbufvar", ...args);
}

/**
 * Returns the `changelist` for the buffer **{buf}**. For the use
 * of **{buf}**, see `bufname()` above. If buffer **{buf}** doesn't
 * exist, an empty list is returned.
 *
 * The returned list contains two entries: a list with the change
 * locations and the current position in the list.  Each
 * entry in the change list is a dictionary with the following
 * entries:
 *         col             column number
 *         coladd          column offset for 'virtualedit'
 *         lnum            line number
 * If buffer **{buf}** is the current buffer, then the current
 * position refers to the position in the list. For other
 * buffers, it is set to the length of the list.
 *
 * Can also be used as a `method`:
 *
 *     GetBufnr()->getchangelist()
 */
export function getchangelist(denops: Denops, buf?: unknown): Promise<unknown>;
export function getchangelist(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getchangelist", ...args);
}

/**
 * Get a single character from the user or input stream.
 * If [expr] is omitted, wait until a character is available.
 * If [expr] is 0, only get a character when one is available.
 *         Return zero otherwise.
 * If [expr] is 1, only check if a character is available, it is
 *         not consumed.  Return zero if no character available.
 * If you prefer always getting a string use `getcharstr()`.
 *
 * Without [expr] and when [expr] is 0 a whole character or
 * special key is returned.  If it is a single character, the
 * result is a Number.  Use `nr2char()` to convert it to a String.
 * Otherwise a String is returned with the encoded character.
 * For a special key it's a String with a sequence of bytes
 * starting with 0x80 (decimal: 128).  This is the same value as
 * the String `"\<Key>"`, e.g., `"\<Left>"`.  The returned value is
 * also a String when a modifier (shift, control, alt) was used
 * that is not included in the character.
 *
 * When [expr] is 0 and Esc is typed, there will be a short delay
 * while Vim waits to see if this is the start of an escape
 * sequence.
 *
 * When [expr] is 1 only the first byte is returned.  For a
 * one-byte character it is the character itself as a number.
 * Use nr2char() to convert it to a String.
 *
 * Use getcharmod() to obtain any additional modifiers.
 *
 * When the user clicks a mouse button, the mouse event will be
 * returned.  The position can then be found in `v:mouse_col`,
 * `v:mouse_lnum`, `v:mouse_winid` and `v:mouse_win`.
 * `getmousepos()` can also be used.  Mouse move events will be
 * ignored.
 * This example positions the mouse as it would normally happen:
 *
 *     let c = getchar()
 *     if c == "\<LeftMouse>" && v:mouse_win > 0
 *       exe v:mouse_win .. "wincmd w"
 *       exe v:mouse_lnum
 *       exe "normal " .. v:mouse_col .. "|"
 *     endif
 *
 * When using bracketed paste only the first character is
 * returned, the rest of the pasted text is dropped.
 * `xterm-bracketed-paste`.
 *
 * There is no prompt, you will somehow have to make clear to the
 * user that a character has to be typed.  The screen is not
 * redrawn, e.g. when resizing the window.  When using a popup
 * window it should work better with a `popup-filter`.
 *
 * There is no mapping for the character.
 * Key codes are replaced, thus when the user presses the `<Del>`
 * key you get the code for the `<Del>` key, not the raw character
 * sequence.  Examples:
 *
 *     getchar() == "\<Del>"
 *     getchar() == "\<S-Left>"
 *
 * This example redefines "f" to ignore case:
 *
 *     :nmap f :call FindChar()<CR>
 *     :function FindChar()
 *     :  let c = nr2char(getchar())
 *     :  while col('.') < col('$') - 1
 *     :    normal l
 *     :    if getline('.')[col('.') - 1] ==? c
 *     :      break
 *     :    endif
 *     :  endwhile
 *     :endfunction
 *
 * You may also receive synthetic characters, such as
 * `<CursorHold>`. Often you will want to ignore this and get
 * another character:
 *
 *     :function GetKey()
 *     :  let c = getchar()
 *     :  while c == "\<CursorHold>"
 *     :    let c = getchar()
 *     :  endwhile
 *     :  return c
 *     :endfunction
 */
export function getchar(denops: Denops, expr?: unknown): Promise<unknown>;
export function getchar(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("getchar", ...args);
}

/**
 * The result is a Number which is the state of the modifiers for
 * the last obtained character with getchar() or in another way.
 * These values are added together:
 *         2       shift
 *         4       control
 *         8       alt (meta)
 *         16      meta (when it's different from ALT)
 *         32      mouse double click
 *         64      mouse triple click
 *         96      mouse quadruple click (== 32 + 64)
 *         128     command (Macintosh only)
 * Only the modifiers that have not been included in the
 * character itself are obtained.  Thus Shift-a results in "A"
 * without a modifier.  Returns 0 if no modifiers are used.
 */
export function getcharmod(denops: Denops): Promise<unknown>;
export function getcharmod(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getcharmod", ...args);
}

/**
 * Get the position for String **{expr}**. Same as `getpos()` but the
 * column number in the returned List is a character index
 * instead of a byte index.
 * If `getpos()` returns a very large column number, equal to
 * `v:maxcol`, then getcharpos() will return the character index
 * of the last character.
 *
 * Example:
 * With the cursor on '세' in line 5 with text "여보세요":
 *
 *     getcharpos('.')         returns [0, 5, 3, 0]
 *     getpos('.')             returns [0, 5, 7, 0]
 *
 * Can also be used as a `method`:
 *
 *     GetMark()->getcharpos()
 */
export function getcharpos(denops: Denops, expr: unknown): Promise<unknown>;
export function getcharpos(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getcharpos", ...args);
}

/**
 * Return the current character search information as a **{dict}**
 * with the following entries:
 *
 *     char        character previously used for a character
 *                 search (`t`, `f`, `T`, or `F`); empty string
 *                 if no character search has been performed
 *     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 always have `;` and `,` search
 * forward/backward regardless of the direction of the previous
 * character search:
 *
 *     :nnoremap <expr> ; getcharsearch().forward ? ';' : ','
 *     :nnoremap <expr> , getcharsearch().forward ? ',' : ';'
 *
 * Also see `setcharsearch()`.
 */
export function getcharsearch(denops: Denops): Promise<unknown>;
export function getcharsearch(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getcharsearch", ...args);
}

/**
 * Get a single character from the user or input stream as a
 * string.
 * If [expr] is omitted, wait until a character is available.
 * If [expr] is 0 or false, only get a character when one is
 *         available.  Return an empty string otherwise.
 * If [expr] is 1 or true, only check if a character is
 *         available, it is not consumed.  Return an empty string
 *         if no character is available.
 * Otherwise this works like `getchar()`, except that a number
 * result is converted to a string.
 */
export function getcharstr(denops: Denops, expr?: unknown): Promise<unknown>;
export function getcharstr(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getcharstr", ...args);
}

/**
 * Return the type of the current command-line completion.
 * Only works when the command line is being edited, thus
 * requires use of `c_CTRL-\_e` or `c_CTRL-R_=`.
 * See `:command-completion` for the return string.
 * Also see `getcmdtype()`, `setcmdpos()`, `getcmdline()` and
 * `setcmdline()`.
 * Returns an empty string when completion is not defined.
 */
export function getcmdcompltype(denops: Denops): Promise<unknown>;
export function getcmdcompltype(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getcmdcompltype", ...args);
}

/**
 * Return the current command-line.  Only works when the command
 * line is being edited, thus requires use of `c_CTRL-\_e` or
 * `c_CTRL-R_=`.
 * Example:
 *
 *     :cmap <F7> <C-\>eescape(getcmdline(), ' \')<CR>
 *
 * Also see `getcmdtype()`, `getcmdpos()`, `setcmdpos()` and
 * `setcmdline()`.
 * Returns an empty string when entering a password or using
 * `inputsecret()`.
 */
export function getcmdline(denops: Denops): Promise<unknown>;
export function getcmdline(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getcmdline", ...args);
}

/**
 * Return the position of the cursor in the command line as a
 * byte count.  The first column is 1.
 * Only works when editing the command line, thus requires use of
 * `c_CTRL-\_e` or `c_CTRL-R_=` or an expression mapping.
 * Returns 0 otherwise.
 * Also see `getcmdtype()`, `setcmdpos()`, `getcmdline()` and
 * `setcmdline()`.
 */
export function getcmdpos(denops: Denops): Promise<unknown>;
export function getcmdpos(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getcmdpos", ...args);
}

/**
 * Return the screen position of the cursor in the command line
 * as a byte count.  The first column is 1.
 * Instead of `getcmdpos()`, it adds the prompt position.
 * Only works when editing the command line, thus requires use of
 * `c_CTRL-\_e` or `c_CTRL-R_=` or an expression mapping.
 * Returns 0 otherwise.
 * Also see `getcmdpos()`, `setcmdpos()`, `getcmdline()` and
 * `setcmdline()`.
 */
export function getcmdscreenpos(denops: Denops): Promise<unknown>;
export function getcmdscreenpos(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getcmdscreenpos", ...args);
}

/**
 * Return the current command-line type. Possible return values
 * are:
 *     :   normal Ex command
 *     >   debug mode command `debug-mode`
 *     /   forward search command
 *     ?   backward search command
 *     @   `input()` command
 *     -   `:insert` or `:append` command
 *     =   `i_CTRL-R_=`
 * Only works when editing the command line, thus requires use of
 * `c_CTRL-\_e` or `c_CTRL-R_=` or an expression mapping.
 * Returns an empty string otherwise.
 * Also see `getcmdpos()`, `setcmdpos()` and `getcmdline()`.
 */
export function getcmdtype(denops: Denops): Promise<unknown>;
export function getcmdtype(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getcmdtype", ...args);
}

/**
 * Return the current `command-line-window` type. Possible return
 * values are the same as `getcmdtype()`. Returns an empty string
 * when not in the command-line window.
 */
export function getcmdwintype(denops: Denops): Promise<unknown>;
export function getcmdwintype(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getcmdwintype", ...args);
}

/**
 * Return a list of command-line completion matches. The String
 * **{type}** argument specifies what for.  The following completion
 * types are supported:
 *
 * arglist         file names in argument list
 * augroup         autocmd groups
 * buffer          buffer names
 * behave          `:behave` suboptions
 * breakpoint      `:breakadd` and `:breakdel` suboptions
 * color           color schemes
 * command         Ex command
 * cmdline         `cmdline-completion` result
 * compiler        compilers
 * cscope          `:cscope` suboptions
 * diff_buffer     `:diffget` and `:diffput` completion
 * dir             directory names
 * environment     environment variable names
 * event           autocommand events
 * expression      Vim expression
 * file            file and directory names
 * file_in_path    file and directory names in `'path'`
 * filetype        filetype names `'filetype'`
 * function        function name
 * help            help subjects
 * highlight       highlight groups
 * history         `:history` suboptions
 * locale          locale names (as output of locale -a)
 * mapclear        buffer argument
 * mapping         mapping name
 * menu            menus
 * messages        `:messages` suboptions
 * option          options
 * packadd         optional package `pack-add` names
 * scriptnames     sourced script names `:scriptnames`
 * shellcmd        Shell command
 * sign            `:sign` suboptions
 * syntax          syntax file names `'syntax'`
 * syntime         `:syntime` suboptions
 * tag             tags
 * tag_listfiles   tags, file names
 * user            user names
 * var             user variables
 *
 * If **{pat}** is an empty string, then all the matches are
 * returned.  Otherwise only items matching **{pat}** are returned.
 * See `wildcards` for the use of special characters in **{pat}**.
 *
 * If the optional **{filtered}** flag is set to 1, then 'wildignore'
 * is applied to filter the results.  Otherwise all the matches
 * are returned. The 'wildignorecase' option always applies.
 *
 * If the 'wildoptions' option contains 'fuzzy', then fuzzy
 * matching is used to get the completion matches. Otherwise
 * regular expression matching is used.  Thus this function
 * follows the user preference, what happens on the command line.
 * If you do not want this you can make 'wildoptions' empty
 * before calling getcompletion() and restore it afterwards.
 *
 * If **{type}** is "cmdline", then the `cmdline-completion` result is
 * returned.  For example, to complete the possible values after
 * a ":call" command:
 *
 *     echo getcompletion('call ', 'cmdline')
 *
 * If there are no matches, an empty list is returned.  An
 * invalid value for **{type}** produces an error.
 *
 * Can also be used as a `method`:
 *
 *     GetPattern()->getcompletion('color')
 */
export function getcompletion(
  denops: Denops,
  pat: unknown,
  type: unknown,
  filtered?: unknown,
): Promise<unknown>;
export function getcompletion(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getcompletion", ...args);
}

/**
 * Same as `getcurpos()` but the column number in the returned
 * List is a character index instead of a byte index.
 *
 * Example:
 * With the cursor on '보' in line 3 with text "여보세요":
 *
 *     getcursorcharpos()      returns [0, 3, 2, 0, 3]
 *     getcurpos()             returns [0, 3, 4, 0, 3]
 *
 * Can also be used as a `method`:
 *
 *     GetWinid()->getcursorcharpos()
 */
export function getcursorcharpos(
  denops: Denops,
  winid?: unknown,
): Promise<unknown>;
export function getcursorcharpos(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getcursorcharpos", ...args);
}

/**
 * The result is a String, which is the name of the current
 * working directory.  'autochdir' is ignored.
 *
 * With **{winnr}** return the local current directory of this window
 * in the current tab page.  **{winnr}** can be the window number or
 * the `window-ID`.
 * If **{winnr}** is -1 return the name of the global working
 * directory.  See also `haslocaldir()`.
 *
 * With **{winnr}** and **{tabnr}** return the local current directory of
 * the window in the specified tab page. If **{winnr}** is -1 return
 * the working directory of the tabpage.
 * If **{winnr}** is zero use the current window, if **{tabnr}** is zero
 * use the current tabpage.
 * Without any arguments, return the actual working directory of
 * the current window.
 * Return an empty string if the arguments are invalid.
 *
 * Examples:
 *
 *     " Get the working directory of the current window
 *     :echo getcwd()
 *     :echo getcwd(0)
 *     :echo getcwd(0, 0)
 *     " Get the working directory of window 3 in tabpage 2
 *     :echo getcwd(3, 2)
 *     " Get the global working directory
 *     :echo getcwd(-1)
 *     " Get the working directory of tabpage 3
 *     :echo getcwd(-1, 3)
 *     " Get the working directory of current tabpage
 *     :echo getcwd(-1, 0)
 *
 * Can also be used as a `method`:
 *
 *     GetWinnr()->getcwd()
 */
export function getcwd(
  denops: Denops,
  winnr?: unknown,
  tabnr?: unknown,
): Promise<unknown>;
export function getcwd(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("getcwd", ...args);
}

/**
 * Return the value of environment variable **{name}**.  The **{name}**
 * argument is a string, without a leading '$'.  Example:
 *
 *     myHome = getenv('HOME')
 *
 * When the variable does not exist `v:null` is returned.  That
 * is different from a variable set to an empty string, although
 * some systems interpret the empty value as the variable being
 * deleted.  See also `expr-env`.
 *
 * Can also be used as a `method`:
 *
 *     GetVarname()->getenv()
 */
export function getenv(denops: Denops, name: unknown): Promise<unknown>;
export function getenv(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("getenv", ...args);
}

/**
 * Without an argument returns the name of the normal font being
 * used.  Like what is used for the Normal highlight group
 * `hl-Normal`.
 * With an argument a check is done whether String **{name}** is a
 * valid font name.  If not then an empty string is returned.
 * Otherwise the actual font name is returned, or **{name}** if the
 * GUI does not support obtaining the real name.
 * Only works when the GUI is running, thus not in your vimrc or
 * gvimrc file.  Use the `GUIEnter` autocommand to use this
 * function just after the GUI has started.
 * Note that the GTK GUI accepts any font name, thus checking for
 * a valid name does not work.
 */
export function getfontname(denops: Denops, name?: unknown): Promise<unknown>;
export function getfontname(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getfontname", ...args);
}

/**
 * The result is a String, which is the read, write, and execute
 * permissions of the given file **{fname}**.
 * If **{fname}** does not exist or its directory cannot be read, an
 * empty string is returned.
 * The result 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.
 * If a user does not have a given permission the flag for this
 * is replaced with the string "-".  Examples:
 *
 *     :echo getfperm("/etc/passwd")
 *     :echo getfperm(expand("~/.vimrc"))
 *
 * This will hopefully (from a security point of view) display
 * the string "rw-r--r--" or even "rw-------".
 *
 * Can also be used as a `method`:
 *
 *     GetFilename()->getfperm()
 *
 * For setting permissions use `setfperm()`.
 */
export function getfperm(denops: Denops, fname: unknown): Promise<unknown>;
export function getfperm(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("getfperm", ...args);
}

/**
 * The result is a Number, which is the size in bytes of the
 * given file **{fname}**.
 * If **{fname}** is a directory, 0 is returned.
 * If the file **{fname}** can't be found, -1 is returned.
 * If the size of **{fname}** is too big to fit in a Number then -2
 * is returned.
 *
 * Can also be used as a `method`:
 *
 *     GetFilename()->getfsize()
 */
export function getfsize(denops: Denops, fname: unknown): Promise<unknown>;
export function getfsize(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("getfsize", ...args);
}

/**
 * The result is a Number, which is the last modification time of
 * the given file **{fname}**.  The value is measured as seconds
 * since 1st Jan 1970, and may be passed to strftime().  See also
 * `localtime()` and `strftime()`.
 * If the file **{fname}** can't be found -1 is returned.
 *
 * Can also be used as a `method`:
 *
 *     GetFilename()->getftime()
 */
export function getftime(denops: Denops, fname: unknown): Promise<unknown>;
export function getftime(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("getftime", ...args);
}

/**
 * The result is a String, which is a description of the kind of
 * file of the given file **{fname}**.
 * If **{fname}** does not exist an empty string is returned.
 * Here is a table over different kinds of files and their
 * results:
 *         Normal file             "file"
 *         Directory               "dir"
 *         Symbolic link           "link"
 *         Block device            "bdev"
 *         Character device        "cdev"
 *         Socket                  "socket"
 *         FIFO                    "fifo"
 *         All other               "other"
 * Example:
 *
 *     getftype("/home")
 *
 * Note that a type such as "link" will only be returned on
 * systems that support it.  On some systems only "dir" and
 * "file" are returned.  On MS-Windows a symbolic link to a
 * directory returns "dir" instead of "link".
 *
 * Can also be used as a `method`:
 *
 *     GetFilename()->getftype()
 */
export function getftype(denops: Denops, fname: unknown): Promise<unknown>;
export function getftype(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("getftype", ...args);
}

/**
 * Returns the `jumplist` for the specified window.
 *
 * Without arguments use the current window.
 * With **{winnr}** only use this window in the current tab page.
 * **{winnr}** can also be a `window-ID`.
 * With **{winnr}** and **{tabnr}** use the window in the specified tab
 * page.  If **{winnr}** or **{tabnr}** is invalid, an empty list is
 * returned.
 *
 * The returned list contains two entries: a list with the jump
 * locations and the last used jump position number in the list.
 * Each entry in the jump location list is a dictionary with
 * the following entries:
 *         bufnr           buffer number
 *         col             column number
 *         coladd          column offset for 'virtualedit'
 *         filename        filename if available
 *         lnum            line number
 *
 * Can also be used as a `method`:
 *
 *     GetWinnr()->getjumplist()
 */
export function getjumplist(
  denops: Denops,
  winnr?: unknown,
  tabnr?: unknown,
): Promise<unknown>;
export function getjumplist(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getjumplist", ...args);
}

/**
 * Returns a `List` with all the entries in 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
 * returned.  For an invalid window number **{nr}**, an empty list is
 * returned. Otherwise, same as `getqflist()`.
 *
 * If the optional **{what}** dictionary argument is supplied, then
 * returns the items listed in **{what}** as a dictionary. Refer to
 * `getqflist()` for the supported items in **{what}**.
 *
 * In addition to the items supported by `getqflist()` in **{what}**,
 * the following item is supported by `getloclist()`:
 *
 *         filewinid       id of the window used to display files
 *                         from the location list. This field is
 *                         applicable only when called from a
 *                         location list window. See
 *                         `location-list-file-window` for more
 *                         details.
 *
 * Returns a `Dictionary` with default values if there is no
 * location list for the window **{nr}**.
 * Returns an empty Dictionary if window **{nr}** does not exist.
 *
 * Examples (See also `getqflist-examples`):
 *
 *     :echo getloclist(3, {'all': 0})
 *     :echo getloclist(5, {'filewinid': 0})
 */
export function getloclist(
  denops: Denops,
  nr: unknown,
  what?: unknown,
): Promise<unknown>;
export function getloclist(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getloclist", ...args);
}

/**
 * Without the **{buf}** argument returns a `List` with information
 * about all the global marks. `mark`
 *
 * If the optional **{buf}** argument is specified, returns the
 * local marks defined in buffer **{buf}**.  For the use of **{buf}**,
 * see `bufname()`.  If **{buf}** is invalid, an empty list is
 * returned.
 *
 * Each item in the returned List is a `Dict` with the following:
 *     mark   name of the mark prefixed by "'"
 *     pos    a `List` with the position of the mark:
 *                 [bufnum, lnum, col, off]
 *            Refer to `getpos()` for more information.
 *     file   file name
 *
 * Refer to `getpos()` for getting information about a specific
 * mark.
 *
 * Can also be used as a `method`:
 *
 *     GetBufnr()->getmarklist()
 */
export function getmarklist(denops: Denops, buf?: unknown): Promise<unknown>;
export function getmarklist(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getmarklist", ...args);
}

/**
 * Returns a `List` with all matches previously defined for the
 * current window by `matchadd()` and the `:match` commands.
 * `getmatches()` is useful in combination with `setmatches()`,
 * as `setmatches()` can restore a list of matches saved by
 * `getmatches()`.
 * If **{win}** is specified, use the window with this number or
 * window ID instead of the current window.  If **{win}** is invalid,
 * an empty list is returned.
 * Example:
 *
 *     :echo getmatches()
 *
 *         [{'group': 'MyGroup1', 'pattern': 'TODO',
 *         'priority': 10, 'id': 1}, {'group': 'MyGroup2',
 *         'pattern': 'FIXME', 'priority': 10, 'id': 2}]
 *
 *             :let m = getmatches()
 *             :call clearmatches()
 *             :echo getmatches()
 *
 *         []
 *
 *             :call setmatches(m)
 *             :echo getmatches()
 *
 *         [{'group': 'MyGroup1', 'pattern': 'TODO',
 *         'priority': 10, 'id': 1}, {'group': 'MyGroup2',
 *         'pattern': 'FIXME', 'priority': 10, 'id': 2}]
 *
 *             :unlet m
 */
export function getmatches(denops: Denops, win?: unknown): Promise<unknown>;
export function getmatches(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getmatches", ...args);
}

/**
 * Returns a `Dictionary` with the last known position of the
 * mouse.  This can be used in a mapping for a mouse click or in
 * a filter of a popup window.  The items are:
 *         screenrow       screen row
 *         screencol       screen column
 *         winid           Window ID of the click
 *         winrow          row inside "winid"
 *         wincol          column inside "winid"
 *         line            text line inside "winid"
 *         column          text column inside "winid"
 * All numbers are 1-based.
 *
 * If not over a window, e.g. when in the command line, then only
 * "screenrow" and "screencol" are valid, the others are zero.
 *
 * When on the status line below a window or the vertical
 * separator right of a window, the "line" and "column" values
 * are zero.
 *
 * When the position is after the text then "column" is the
 * length of the text in bytes plus one.
 *
 * If the mouse is over a popup window then that window is used.
 *
 * When using `getchar()` the Vim variables `v:mouse_lnum`,
 * `v:mouse_col` and `v:mouse_winid` also provide these values.
 */
export function getmousepos(denops: Denops): Promise<unknown>;
export function getmousepos(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getmousepos", ...args);
}

/**
 * Return a Number which is the process ID of the Vim process.
 * On Unix and MS-Windows this is a unique number, until Vim
 * exits.
 */
export function getpid(denops: Denops): Promise<unknown>;
export function getpid(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("getpid", ...args);
}

/**
 * Returns a `List` with all the current quickfix errors.  Each
 * list item is a dictionary with these entries:
 *         bufnr   number of buffer that has the file name, use
 *                 bufname() to get the name
 *         module  module name
 *         lnum    line number in the buffer (first line is 1)
 *         end_lnum
 *                 end of line number if the item is multiline
 *         col     column number (first column is 1)
 *         end_col end of column number if the item has range
 *         vcol    `TRUE`: "col" is visual column
 *                 `FALSE`: "col" is byte index
 *         nr      error number
 *         pattern search pattern used to locate the error
 *         text    description of the error
 *         type    type of the error, 'E', '1', etc.
 *         valid   `TRUE`: recognized error message
 *
 * When there is no error list or it's empty, an empty list is
 * returned. Quickfix list entries with a non-existing buffer
 * number are returned with "bufnr" set to zero (Note: some
 * functions accept buffer number zero for the alternate buffer,
 * you may need to explicitly check for zero).
 *
 * Useful application: Find pattern matches in multiple files and
 * do something with them:
 *
 *     :vimgrep /theword/jg *.c
 *     :for d in getqflist()
 *     :   echo bufname(d.bufnr) ':' d.lnum '=' d.text
 *     :endfor
 *
 * If the optional **{what}** dictionary argument is supplied, then
 * returns only the items listed in **{what}** as a dictionary. The
 * following string items are supported in **{what}**:
 *         changedtick     get the total number of changes made
 *                         to the list `quickfix-changedtick`
 *         context get the `quickfix-context`
 *         efm     errorformat to use when parsing "lines". If
 *                 not present, then the 'errorformat' option
 *                 value is used.
 *         id      get information for the quickfix list with
 *                 `quickfix-ID`; zero means the id for the
 *                 current list or the list specified by "nr"
 *         idx     get information for the quickfix entry at this
 *                 index in the list specified by 'id' or 'nr'.
 *                 If set to zero, then uses the current entry.
 *                 See `quickfix-index`
 *         items   quickfix list entries
 *         lines   parse a list of lines using 'efm' and return
 *                 the resulting entries.  Only a `List` type is
 *                 accepted.  The current quickfix list is not
 *                 modified. See `quickfix-parse`.
 *         nr      get information for this quickfix list; zero
 *                 means the current quickfix list and "$" means
 *                 the last quickfix list
 *         qfbufnr number of the buffer displayed in the quickfix
 *                 window. Returns 0 if the quickfix buffer is
 *                 not present. See `quickfix-buffer`.
 *         size    number of entries in the quickfix list
 *         title   get the list title `quickfix-title`
 *         winid   get the quickfix `window-ID`
 *         all     all of the above quickfix properties
 * Non-string items in **{what}** are ignored. To get the value of a
 * particular item, set it to zero.
 * If "nr" is not present then the current quickfix list is used.
 * If both "nr" and a non-zero "id" are specified, then the list
 * specified by "id" is used.
 * To get the number of lists in the quickfix stack, set "nr" to
 * "$" in **{what}**. The "nr" value in the returned dictionary
 * contains the quickfix stack size.
 * When "lines" is specified, all the other items except "efm"
 * are ignored.  The returned dictionary contains the entry
 * "items" with the list of entries.
 *
 * The returned dictionary contains the following entries:
 *         changedtick     total number of changes made to the
 *                         list `quickfix-changedtick`
 *         context quickfix list context. See `quickfix-context`
 *                 If not present, set to "".
 *         id      quickfix list ID `quickfix-ID`. If not
 *                 present, set to 0.
 *         idx     index of the quickfix entry in the list. If not
 *                 present, set to 0.
 *         items   quickfix list entries. If not present, set to
 *                 an empty list.
 *         nr      quickfix list number. If not present, set to 0
 *         qfbufnr number of the buffer displayed in the quickfix
 *                 window. If not present, set to 0.
 *         size    number of entries in the quickfix list. If not
 *                 present, set to 0.
 *         title   quickfix list title text. If not present, set
 *                 to "".
 *         winid   quickfix `window-ID`. If not present, set to 0
 *
 * Examples (See also `getqflist-examples`):
 *
 *     :echo getqflist({'all': 1})
 *     :echo getqflist({'nr': 2, 'title': 1})
 *     :echo getqflist({'lines' : ["F1:10:L10"]})
 */
export function getqflist(denops: Denops, what?: unknown): Promise<unknown>;
export function getqflist(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getqflist", ...args);
}

/**
 * The result is a String, which is the contents of register
 * **{regname}**.  Example:
 *
 *     :let cliptext = getreg('*')
 *
 * When register **{regname}** was not set the result is an empty
 * string.
 * The **{regname}** argument must be a string.
 *
 * getreg('=') returns the last evaluated value of the expression
 * register.  (For use in maps.)
 * getreg('=', 1) returns the expression itself, so that it can
 * be restored with `setreg()`.  For other registers the extra
 * argument is ignored, thus you can always give it.
 *
 * If **{list}** is present and `TRUE`, the result type is changed
 * to `List`. Each list item is one text line. Use it if you care
 * about zero bytes possibly present inside register: without
 * third argument both NLs and zero bytes are represented as NLs
 * (see `NL-used-for-Nul`).
 * When the register was not set an empty list is returned.
 *
 * If **{regname}** is "", the unnamed register '"' is used.
 * If **{regname}** is not specified, `v:register` is used.
 * In `Vim9-script` **{regname}** must be one character.
 *
 * Can also be used as a `method`:
 *
 *     GetRegname()->getreg()
 */
export function getreg(
  denops: Denops,
  regname?: unknown,
  v1?: unknown,
  list?: unknown,
): Promise<unknown>;
export function getreg(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("getreg", ...args);
}

/**
 * The result is a String, which is type of register **{regname}**.
 * The value will be one of:
 *     "v"                 for `characterwise` text
 *     "V"                 for `linewise` text
 *     `"<CTRL-V>{width}"`   for `blockwise-visual` text
 *     ""                  for an empty or unknown register
 * `<CTRL-V>` is one character with value 0x16.
 * The **{regname}** argument is a string.  If **{regname}** is "", the
 * unnamed register '"' is used.  If **{regname}** is not specified,
 * `v:register` is used.
 * In `Vim9-script` **{regname}** must be one character.
 *
 * Can also be used as a `method`:
 *
 *     GetRegname()->getregtype()
 */
export function getregtype(denops: Denops, regname?: unknown): Promise<unknown>;
export function getregtype(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getregtype", ...args);
}

/**
 * If **{tabnr}** is not specified, then information about all the
 * tab pages is returned as a `List`. Each List item is a
 * `Dictionary`.  Otherwise, **{tabnr}** specifies the tab page
 * number and information about that one is returned.  If the tab
 * page does not exist an empty List is returned.
 *
 * Each List item is a `Dictionary` with the following entries:
 *         tabnr           tab page number.
 *         variables       a reference to the dictionary with
 *                         tabpage-local variables
 *         windows         List of `window-ID`s in the tab page.
 *
 * Can also be used as a `method`:
 *
 *     GetTabnr()->gettabinfo()
 */
export function gettabinfo(denops: Denops, tabnr?: unknown): Promise<unknown>;
export function gettabinfo(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("gettabinfo", ...args);
}

/**
 * Get the value of a tab-local variable **{varname}** in tab page
 * **{tabnr}**. `t:var`
 * Tabs are numbered starting with one.
 * The **{varname}** argument is a string.  When **{varname}** is empty a
 * dictionary with all tab-local variables is returned.
 * Note that the name without "t:" must be used.
 * When the tab or variable doesn't exist **{def}** or an empty
 * string is returned, there is no error message.
 *
 * Can also be used as a `method`:
 *
 *     GetTabnr()->gettabvar(varname)
 */
export function gettabvar(
  denops: Denops,
  tabnr: unknown,
  varname: unknown,
  def?: unknown,
): Promise<unknown>;
export function gettabvar(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("gettabvar", ...args);
}

/**
 * Get the value of window-local variable **{varname}** in window
 * **{winnr}** in tab page **{tabnr}**.
 * The **{varname}** argument is a string.  When **{varname}** is empty a
 * dictionary with all window-local variables is returned.
 * When **{varname}** is equal to "&" get the values of all
 * window-local options in a `Dictionary`.
 * Otherwise, when **{varname}** starts with "&" get the value of a
 * window-local option.
 * Note that **{varname}** must be the name without "w:".
 * Tabs are numbered starting with one.  For the current tabpage
 * use `getwinvar()`.
 * **{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 option, buffer-local option and
 * window-local option, but it doesn't work for a global variable
 * or buffer-local variable.
 * When the tab, window or variable doesn't exist **{def}** or an
 * empty string is returned, there is no error message.
 * Examples:
 *
 *     :let list_is_on = gettabwinvar(1, 2, '&list')
 *     :echo "myvar = " .. gettabwinvar(3, 1, 'myvar')
 *
 * To obtain all window-local variables use:
 *
 *     gettabwinvar({tabnr}, {winnr}, '&')
 *
 * Can also be used as a `method`:
 *
 *     GetTabnr()->gettabwinvar(winnr, varname)
 */
export function gettabwinvar(
  denops: Denops,
  tabnr: unknown,
  winnr: unknown,
  varname: unknown,
  def?: unknown,
): Promise<unknown>;
export function gettabwinvar(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("gettabwinvar", ...args);
}

/**
 * The result is a Dict, which is the tag stack of window **{winnr}**.
 * **{winnr}** can be the window number or the `window-ID`.
 * When **{winnr}** is not specified, the current window is used.
 * When window **{winnr}** doesn't exist, an empty Dict is returned.
 *
 * The returned dictionary contains the following entries:
 *         curidx          Current index in the stack. When at
 *                         top of the stack, set to (length + 1).
 *                         Index of bottom of the stack is 1.
 *         items           List of items in the stack. Each item
 *                         is a dictionary containing the
 *                         entries described below.
 *         length          Number of entries in the stack.
 *
 * Each item in the stack is a dictionary with the following
 * entries:
 *         bufnr           buffer number of the current jump
 *         from            cursor position before the tag jump.
 *                         See `getpos()` for the format of the
 *                         returned list.
 *         matchnr         current matching tag number. Used when
 *                         multiple matching tags are found for a
 *                         name.
 *         tagname         name of the tag
 *
 * See `tagstack` for more information about the tag stack.
 *
 * Can also be used as a `method`:
 *
 *     GetWinnr()->gettagstack()
 */
export function gettagstack(denops: Denops, winnr?: unknown): Promise<unknown>;
export function gettagstack(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("gettagstack", ...args);
}

/**
 * Returns information about windows as a `List` with Dictionaries.
 *
 * If **{winid}** is given Information about the window with that ID
 * is returned, as a `List` with one item.  If the window does not
 * exist the result is an empty list.
 *
 * Without **{winid}** information about all the windows in all the
 * tab pages is returned.
 *
 * Each List item is a `Dictionary` with the following entries:
 *         botline         last complete displayed buffer line
 *         bufnr           number of buffer in the window
 *         height          window height (excluding winbar)
 *         loclist         1 if showing a location list
 *                         *only with the +quickfix feature*
 *         quickfix        1 if quickfix or location list window
 *                         *only with the +quickfix feature*
 *         terminal        1 if a terminal window
 *                         *only with the +terminal feature*
 *         tabnr           tab page number
 *         topline         first displayed buffer line
 *         variables       a reference to the dictionary with
 *                         window-local variables
 *         width           window width
 *         winbar          1 if the window has a toolbar, 0
 *                         otherwise
 *         wincol          leftmost screen column of the window;
 *                         "col" from `win_screenpos()`
 *         textoff         number of columns occupied by any
 *                         'foldcolumn', 'signcolumn' and line
 *                         number in front of the text
 *         winid           `window-ID`
 *         winnr           window number
 *         winrow          topmost screen line of the window;
 *                         "row" from `win_screenpos()`
 *
 * Can also be used as a `method`:
 *
 *     GetWinnr()->getwininfo()
 */
export function getwininfo(denops: Denops, winid?: unknown): Promise<unknown>;
export function getwininfo(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getwininfo", ...args);
}

/**
 * The result is a `List` with two numbers, the result of
 * `getwinposx()` and `getwinposy()` combined:
 *         [x-pos, y-pos]
 * **{timeout}** can be used to specify how long to wait in msec for
 * a response from the terminal.  When omitted 100 msec is used.
 * Use a longer time for a remote terminal.
 * When using a value less than 10 and no response is received
 * within that time, a previously reported position is returned,
 * if available.  This can be used to poll for the position and
 * do some work in the meantime:
 *
 *     while 1
 *       let res = getwinpos(1)
 *       if res[0] >= 0
 *         break
 *       endif
 *       " Do some work here
 *     endwhile
 *
 * Can also be used as a `method`:
 *
 *     GetTimeout()->getwinpos()
 */
export function getwinpos(denops: Denops, timeout?: unknown): Promise<unknown>;
export function getwinpos(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getwinpos", ...args);
}

/**
 * The result is a Number, which is the X coordinate in pixels of
 * the left hand side of the GUI Vim window. Also works for an
 * xterm (uses a timeout of 100 msec).
 * The result will be -1 if the information is not available.
 * The value can be used with `:winpos`.
 */
export function getwinposx(denops: Denops): Promise<unknown>;
export function getwinposx(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getwinposx", ...args);
}

/**
 * The result is a Number, which is the Y coordinate in pixels of
 * the top of the GUI Vim window.  Also works for an xterm (uses
 * a timeout of 100 msec).
 * The result will be -1 if the information is not available.
 * The value can be used with `:winpos`.
 */
export function getwinposy(denops: Denops): Promise<unknown>;
export function getwinposy(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getwinposy", ...args);
}

/**
 * Like `gettabwinvar()` for the current tabpage.
 * Examples:
 *
 *     :let list_is_on = getwinvar(2, '&list')
 *     :echo "myvar = " .. getwinvar(1, 'myvar')
 *
 * Can also be used as a `method`:
 *
 *     GetWinnr()->getwinvar(varname)
 */
export function getwinvar(
  denops: Denops,
  winnr: unknown,
  varname: unknown,
  def?: unknown,
): Promise<unknown>;
export function getwinvar(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("getwinvar", ...args);
}

/**
 * Expand the file wildcards in **{expr}**.  See `wildcards` for the
 * use of special characters.
 *
 * Unless the optional **{nosuf}** argument is given and is `TRUE`,
 * the 'suffixes' and 'wildignore' options apply: Names matching
 * one of the patterns in 'wildignore' will be skipped and
 * 'suffixes' affect the ordering of matches.
 * 'wildignorecase' always applies.
 *
 * When **{list}** is present and it is `TRUE` the result is a `List`
 * with all matching files. The advantage of using a List is,
 * you also get filenames containing newlines correctly.
 * Otherwise the result is a String and when there are several
 * matches, they are separated by `<NL>` characters.
 *
 * If the expansion fails, the result is an empty String or List.
 *
 * You can also use `readdir()` if you need to do complicated
 * things, such as limiting the number of matches.
 *
 * A name for a non-existing file is not included.  A symbolic
 * link is only included if it points to an existing file.
 * However, when the **{alllinks}** argument is present and it is
 * `TRUE` then all symbolic links are included.
 *
 * For most systems backticks can be used to get files names from
 * any external command.  Example:
 *
 *     :let tagfiles = glob("`find . -name tags -print`")
 *     :let &tags = substitute(tagfiles, "\n", ",", "g")
 *
 * The result of the program inside the backticks should be one
 * item per line.  Spaces inside an item are allowed.
 *
 * See `expand()` for expanding special Vim variables.  See
 * `system()` for getting the raw output of an external command.
 *
 * Can also be used as a `method`:
 *
 *     GetExpr()->glob()
 */
export function glob(
  denops: Denops,
  expr: unknown,
  nosuf?: unknown,
  list?: unknown,
  alllinks?: unknown,
): Promise<unknown>;
export function glob(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("glob", ...args);
}

/**
 * Convert a file pattern, as used by glob(), into a search
 * pattern.  The result can be used to match with a string that
 * is a file name.  E.g.
 *
 *     if filename =~ glob2regpat('Make*.mak')
 *
 * This is equivalent to:
 *
 *     if filename =~ '^Make.*\.mak$'
 *
 * When **{string}** is an empty string the result is "^$", match an
 * empty string.
 * Note that the result depends on the system.  On MS-Windows
 * a backslash usually means a path separator.
 *
 * Can also be used as a `method`:
 *
 *     GetExpr()->glob2regpat()
 */
export function glob2regpat(denops: Denops, string: unknown): Promise<unknown>;
export function glob2regpat(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("glob2regpat", ...args);
}

/**
 * Perform glob() for String **{expr}** on all directories in **{path}**
 * and concatenate the results.  Example:
 *
 *     :echo globpath(&rtp, "syntax/c.vim")
 *
 * **{path}** is a comma-separated list of directory names.  Each
 * directory name is prepended to **{expr}** and expanded like with
 * `glob()`.  A path separator is inserted when needed.
 * To add a comma inside a directory name escape it with a
 * backslash.  Note that on MS-Windows a directory may have a
 * trailing backslash, remove it if you put a comma after it.
 * If the expansion fails for one of the directories, there is no
 * error message.
 *
 * Unless the optional **{nosuf}** argument is given and is `TRUE`,
 * the 'suffixes' and 'wildignore' options apply: Names matching
 * one of the patterns in 'wildignore' will be skipped and
 * 'suffixes' affect the ordering of matches.
 *
 * When **{list}** is present and it is `TRUE` the result is a `List`
 * with all matching files. The advantage of using a List is, you
 * also get filenames containing newlines correctly. Otherwise
 * the result is a String and when there are several matches,
 * they are separated by `<NL>` characters.  Example:
 *
 *     :echo globpath(&rtp, "syntax/c.vim", 0, 1)
 *
 * **{alllinks}** is used as with `glob()`.
 *
 * The "**" item can be used to search in a directory tree.
 * For example, to find all "README.txt" files in the directories
 * in 'runtimepath' and below:
 *
 *     :echo globpath(&rtp, "** /README.txt")
 *
 * Upwards search and limiting the depth of "**" is not
 * supported, thus using 'path' will not always work properly.
 *
 * Can also be used as a `method`, the base is passed as the
 * second argument:
 *
 *     GetExpr()->globpath(&rtp)
 */
export function globpath(
  denops: Denops,
  path: unknown,
  expr: unknown,
  nosuf?: unknown,
  list?: unknown,
  alllinks?: unknown,
): Promise<unknown>;
export function globpath(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("globpath", ...args);
}

/**
 * The result is a Number, which is TRUE if `Dictionary` **{dict}**
 * has an entry with key **{key}**.  FALSE otherwise.
 * The **{key}** argument is a string.  In `Vim9` script a number is
 * also accepted (and converted to a string) but no other types.
 * In legacy script the usual automatic conversion to string is
 * done.
 *
 * Can also be used as a `method`:
 *
 *     mydict->has_key(key)
 */
export function has_key(
  denops: Denops,
  dict: unknown,
  key: unknown,
): Promise<unknown>;
export function has_key(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("has_key", ...args);
}

/**
 * The result is a Number:
 *     1   when the window has set a local directory via `:lcd`
 *     2   when the tab-page has set a local directory via `:tcd`
 *     0   otherwise.
 *
 * Without arguments use the current window.
 * With **{winnr}** use this window in the current tab page.
 * With **{winnr}** and **{tabnr}** use the window in the specified tab
 * page.
 * **{winnr}** can be the window number or the `window-ID`.
 * If **{winnr}** is -1 it is ignored and only the tabpage is used.
 * Return 0 if the arguments are invalid.
 * Examples:
 *
 *     if haslocaldir() == 1
 *       " window local directory case
 *     elseif haslocaldir() == 2
 *       " tab-local directory case
 *     else
 *       " global directory case
 *     endif
 *
 *     " current window
 *     :echo haslocaldir()
 *     :echo haslocaldir(0)
 *     :echo haslocaldir(0, 0)
 *     " window n in current tab page
 *     :echo haslocaldir(n)
 *     :echo haslocaldir(n, 0)
 *     " window n in tab page m
 *     :echo haslocaldir(n, m)
 *     " tab page m
 *     :echo haslocaldir(-1, m)
 *
 * Can also be used as a `method`:
 *
 *     GetWinnr()->haslocaldir()
 */
export function haslocaldir(
  denops: Denops,
  winnr?: unknown,
  tabnr?: unknown,
): Promise<unknown>;
export function haslocaldir(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("haslocaldir", ...args);
}

/**
 * The result is a Number, which is TRUE if there is a mapping
 * that contains **{what}** in somewhere in the rhs (what it is
 * mapped to) and this mapping exists in one of the modes
 * indicated by **{mode}**.
 * The arguments **{what}** and **{mode}** are strings.
 * When **{abbr}** is there and it is `TRUE` use abbreviations
 * instead of mappings.  Don't forget to specify Insert and/or
 * Command-line mode.
 * Both the global mappings and the mappings local to the current
 * buffer are checked for a match.
 * If no matching mapping is found FALSE is returned.
 * The following characters are recognized in **{mode}**:
 *         n       Normal mode
 *         v       Visual and Select mode
 *         x       Visual mode
 *         s       Select mode
 *         o       Operator-pending mode
 *         i       Insert mode
 *         l       Language-Argument ("r", "f", "t", etc.)
 *         c       Command-line mode
 * When **{mode}** is omitted, "nvo" is used.
 *
 * This function is useful to check if a mapping already exists
 * to a function in a Vim script.  Example:
 *
 *     :if !hasmapto('\ABCdoit')
 *     :   map <Leader>d \ABCdoit
 *     :endif
 *
 * This installs the mapping to "\ABCdoit" only if there isn't
 * already a mapping to "\ABCdoit".
 *
 * Can also be used as a `method`:
 *
 *     GetRHS()->hasmapto()
 */
export function hasmapto(
  denops: Denops,
  what: unknown,
  mode?: unknown,
  abbr?: unknown,
): Promise<unknown>;
export function hasmapto(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("hasmapto", ...args);
}

/**
 * Add the String **{item}** to the history **{history}** which can be
 * one of:
 *         "cmd"    or ":"   command line history
 *         "search" or "/"   search pattern history
 *         "expr"   or "="   typed expression history
 *         "input"  or "@"   input line history
 *         "debug"  or ">"   debug command history
 *         empty             the current or last used history
 * The **{history}** string does not need to be the whole name, one
 * character is sufficient.
 * If **{item}** does already exist in the history, it will be
 * shifted to become the newest entry.
 * The result is a Number: TRUE if the operation was successful,
 * otherwise FALSE is returned.
 *
 * Example:
 *
 *     :call histadd("input", strftime("%Y %b %d"))
 *     :let date=input("Enter date: ")
 *
 * This function is not available in the `sandbox`.
 *
 * Can also be used as a `method`, the base is passed as the
 * second argument:
 *
 *     GetHistory()->histadd('search')
 */
export function histadd(
  denops: Denops,
  history: unknown,
  item: unknown,
): Promise<unknown>;
export function histadd(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("histadd", ...args);
}

/**
 * Clear **{history}**, i.e. delete all its entries.  See `hist-names`
 * for the possible values of **{history}**.
 *
 * If the parameter **{item}** evaluates to a String, it is used as a
 * regular expression.  All entries matching that expression will
 * be removed from the history (if there are any).
 * Upper/lowercase must match, unless "\c" is used `/\c`.
 * If **{item}** evaluates to a Number, it will be interpreted as
 * an index, see `:history-indexing`.  The respective entry will
 * be removed if it exists.
 *
 * The result is TRUE for a successful operation, otherwise FALSE
 * is returned.
 *
 * Examples:
 * Clear expression register history:
 *
 *     :call histdel("expr")
 *
 * Remove all entries starting with "*" from the search history:
 *
 *     :call histdel("/", '^\*')
 *
 * The following three are equivalent:
 *
 *     :call histdel("search", histnr("search"))
 *     :call histdel("search", -1)
 *     :call histdel("search", '^' .. histget("search", -1) .. '$')
 *
 * To delete the last search pattern and use the last-but-one for
 * the "n" command and 'hlsearch':
 *
 *     :call histdel("search", -1)
 *     :let @/ = histget("search", -1)
 *
 * Can also be used as a `method`:
 *
 *     GetHistory()->histdel()
 */
export function histdel(
  denops: Denops,
  history: unknown,
  item?: unknown,
): Promise<unknown>;
export function histdel(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("histdel", ...args);
}

/**
 * The result is a String, the entry with Number **{index}** from
 * **{history}**.  See `hist-names` for the possible values of
 * **{history}**, and `:history-indexing` for **{index}**.  If there is
 * no such entry, an empty String is returned.  When **{index}** is
 * omitted, the most recent item from the history is used.
 *
 * Examples:
 * Redo the second last search from history.
 *
 *     :execute '/' .. histget("search", -2)
 *
 * Define an Ex command ":H **{num}**" that supports re-execution of
 * the **{num}**th entry from the output of `:history`.
 *
 *     :command -nargs=1 H execute histget("cmd", 0+<args>)
 *
 * Can also be used as a `method`:
 *
 *     GetHistory()->histget()
 */
export function histget(
  denops: Denops,
  history: unknown,
  index?: unknown,
): Promise<unknown>;
export function histget(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("histget", ...args);
}

/**
 * The result is the Number of the current entry in **{history}**.
 * See `hist-names` for the possible values of **{history}**.
 * If an error occurred, -1 is returned.
 *
 * Example:
 *
 *     :let inp_index = histnr("expr")
 *
 * Can also be used as a `method`:
 *
 *     GetHistory()->histnr()
 */
export function histnr(denops: Denops, history: unknown): Promise<unknown>;
export function histnr(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("histnr", ...args);
}

/**
 * The result is a Number, which is TRUE if a highlight group
 * called **{name}** exists.  This is when the group has been
 * defined in some way.  Not necessarily when highlighting has
 * been defined for it, it may also have been used for a syntax
 * item.
 *
 * Obsolete name: highlight_exists().
 *
 * Can also be used as a `method`:
 *
 *     GetName()->hlexists()
 */
export function hlexists(denops: Denops, name: unknown): Promise<unknown>;
export function hlexists(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("hlexists", ...args);
}

/**
 * The result is a Number, which is the ID of the highlight group
 * with name **{name}**.  When the highlight group doesn't exist,
 * zero is returned.
 * This can be used to retrieve information about the highlight
 * group.  For example, to get the background color of the
 * "Comment" group:
 *
 *     :echo synIDattr(synIDtrans(hlID("Comment")), "bg")
 *
 * Obsolete name: highlightID().
 *
 * Can also be used as a `method`:
 *
 *     GetName()->hlID()
 */
export function hlID(denops: Denops, name: unknown): Promise<unknown>;
export function hlID(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("hlID", ...args);
}

/**
 * The result is a String, which is the name of the machine on
 * which Vim is currently running.  Machine names greater than
 * 256 characters long are truncated.
 */
export function hostname(denops: Denops): Promise<unknown>;
export function hostname(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("hostname", ...args);
}

/**
 * The result is a String, which is the text **{string}** converted
 * from encoding **{from}** to encoding **{to}**.
 * When the conversion completely fails an empty string is
 * returned.  When some characters could not be converted they
 * are replaced with "?".
 * The encoding names are whatever the iconv() library function
 * can accept, see ":!man 3 iconv".
 * Most conversions require Vim to be compiled with the `+iconv`
 * feature.  Otherwise only UTF-8 to latin1 conversion and back
 * can be done.
 * This can be used to display messages with special characters,
 * no matter what 'encoding' is set to.  Write the message in
 * UTF-8 and use:
 *
 *     echo iconv(utf8_str, "utf-8", &enc)
 *
 * Note that Vim uses UTF-8 for all Unicode encodings, conversion
 * from/to UCS-2 is automatically changed to use UTF-8.  You
 * cannot use UCS-2 in a string anyway, because of the NUL bytes.
 *
 * Can also be used as a `method`:
 *
 *     GetText()->iconv('latin1', 'utf-8')
 */
export function iconv(
  denops: Denops,
  string: unknown,
  from: unknown,
  to: unknown,
): Promise<unknown>;
export function iconv(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("iconv", ...args);
}

/**
 * The result is a Number, which is indent of line **{lnum}** in the
 * current buffer.  The indent is counted in spaces, the value
 * of 'tabstop' is relevant.  **{lnum}** is used just like in
 * `getline()`.
 * When **{lnum}** is invalid -1 is returned.  In `Vim9` script an
 * error is given.
 *
 * Can also be used as a `method`:
 *
 *     GetLnum()->indent()
 */
export function indent(denops: Denops, lnum: unknown): Promise<unknown>;
export function indent(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("indent", ...args);
}

/**
 * Find **{expr}** in **{object}** and return its index.  See
 * `indexof()` for using a lambda to select the item.
 *
 * If **{object}** is a `List` return the lowest index where the item
 * has a value equal to **{expr}**.  There is no automatic
 * conversion, so the String "4" is different from the Number 4.
 * And the number 4 is different from the Float 4.0.  The value
 * of 'ignorecase' is not used here, case matters as indicated by
 * the **{ic}** argument.
 *
 * If **{object}** is `Blob` return the lowest index where the byte
 * value is equal to **{expr}**.
 *
 * If **{start}** is given then start looking at the item with index
 * **{start}** (may be negative for an item relative to the end).
 *
 * When **{ic}** is given and it is `TRUE`, ignore case.  Otherwise
 * case must match.
 *
 * -1 is returned when **{expr}** is not found in **{object}**.
 * Example:
 *
 *     :let idx = index(words, "the")
 *     :if index(numbers, 123) >= 0
 *
 * Can also be used as a `method`:
 *
 *     GetObject()->index(what)
 */
export function index(
  denops: Denops,
  object: unknown,
  expr: unknown,
  start?: unknown,
  ic?: unknown,
): Promise<unknown>;
export function index(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("index", ...args);
}

/**
 * When **{object}** is a `List` or a `Blob` insert **{item}** at the start
 * of it.
 *
 * If **{idx}** is specified insert **{item}** before the item with index
 * **{idx}**.  If **{idx}** is zero it goes before the first item, just
 * like omitting **{idx}**.  A negative **{idx}** is also possible, see
 * `list-index`.  -1 inserts just before the last item.
 *
 * Returns the resulting `List` or `Blob`.  Examples:
 *
 *     :let mylist = insert([2, 3, 5], 1)
 *     :call insert(mylist, 4, -1)
 *     :call insert(mylist, 6, len(mylist))
 *
 * The last example can be done simpler with `add()`.
 * Note that when **{item}** is a `List` it is inserted as a single
 * item.  Use `extend()` to concatenate `Lists`.
 *
 * Can also be used as a `method`:
 *
 *     mylist->insert(item)
 */
export function insert(
  denops: Denops,
  object: unknown,
  item: unknown,
  idx?: unknown,
): Promise<unknown>;
export function insert(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("insert", ...args);
}

/**
 * Interrupt script execution.  It works more or less like the
 * user typing CTRL-C, most commands won't execute and control
 * returns to the user.  This is useful to abort execution
 * from lower down, e.g. in an autocommand.  Example:
 *
 *     :function s:check_typoname(file)
 *     :   if fnamemodify(a:file, ':t') == '['
 *     :       echomsg 'Maybe typo'
 *     :       call interrupt()
 *     :   endif
 *     :endfunction
 *     :au BufWritePre * call s:check_typoname(expand('<amatch>'))
 */
export function interrupt(denops: Denops): Promise<unknown>;
export function interrupt(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("interrupt", ...args);
}

/**
 * Bitwise invert.  The argument is converted to a number.  A
 * List, Dict or Float argument causes an error.  Example:
 *
 *     :let bits = invert(bits)
 *
 * Can also be used as a `method`:
 *
 *     :let bits = bits->invert()
 */
export function invert(denops: Denops, expr: unknown): Promise<unknown>;
export function invert(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("invert", ...args);
}

/**
 * The result is a Number, which is `TRUE` when a directory
 * with the name **{directory}** exists.  If **{directory}** doesn't
 * exist, or isn't a directory, the result is `FALSE`.  **{directory}**
 * is any expression, which is used as a String.
 *
 * Can also be used as a `method`:
 *
 *     GetName()->isdirectory()
 */
export function isdirectory(
  denops: Denops,
  directory: unknown,
): Promise<unknown>;
export function isdirectory(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("isdirectory", ...args);
}

/**
 * Return 1 if **{expr}** is a positive infinity, or -1 a negative
 * infinity, otherwise 0.
 *
 *     :echo isinf(1.0 / 0.0)
 *
 *         1
 *
 *     :echo isinf(-1.0 / 0.0)
 *
 *         -1
 *
 * Can also be used as a `method`:
 *
 *     Compute()->isinf()
 *
 * *only available when compiled with the `+float` feature*
 */
export function isinf(denops: Denops, expr: unknown): Promise<unknown>;
export function isinf(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("isinf", ...args);
}

/**
 * The result is a Number, which is `TRUE` when **{expr}** is the
 * name of a locked variable.
 * The string argument **{expr}** must be the name of a variable,
 * `List` item or `Dictionary` entry, not the variable itself!
 * Example:
 *
 *     :let alist = [0, ['a', 'b'], 2, 3]
 *     :lockvar 1 alist
 *     :echo islocked('alist')         " 1
 *     :echo islocked('alist[1]')      " 0
 *
 * When **{expr}** is a variable that does not exist -1 is returned.
 * If **{expr}** uses a range, list or dict index that is out of
 * range or does not exist you get an error message.  Use
 * `exists()` to check for existence.
 * In Vim9 script it does not work for local function variables.
 *
 * Can also be used as a `method`:
 *
 *     GetName()->islocked()
 */
export function islocked(denops: Denops, expr: unknown): Promise<unknown>;
export function islocked(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("islocked", ...args);
}

/**
 * Return `TRUE` if **{expr}** is a float with value NaN.
 *
 *     echo isnan(0.0 / 0.0)
 *
 *         1
 *
 * Can also be used as a `method`:
 *
 *     Compute()->isnan()
 *
 * *only available when compiled with the `+float` feature*
 */
export function isnan(denops: Denops, expr: unknown): Promise<unknown>;
export function isnan(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("isnan", ...args);
}

/**
 * Return a `List` with all the key-value pairs of **{dict}**.  Each
 * `List` item is a list with two items: the key of a **{dict}**
 * entry and the value of this entry.  The `List` is in arbitrary
 * order.  Also see `keys()` and `values()`.
 * Example:
 *
 *     for [key, value] in items(mydict)
 *        echo key .. ': ' .. value
 *     endfor
 *
 * Can also be used as a `method`:
 *
 *     mydict->items()
 */
export function items(denops: Denops, dict: unknown): Promise<unknown>;
export function items(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("items", ...args);
}

/**
 * Join the items in **{list}** together into one String.
 * When **{sep}** is specified it is put in between the items.  If
 * **{sep}** is omitted a single space is used.
 * Note that **{sep}** is not added at the end.  You might want to
 * add it there too:
 *
 *     let lines = join(mylist, "\n") .. "\n"
 *
 * String items are used as-is.  `Lists` and `Dictionaries` are
 * converted into a string like with `string()`.
 * The opposite function is `split()`.
 *
 * Can also be used as a `method`:
 *
 *     mylist->join()
 */
export function join(
  denops: Denops,
  list: unknown,
  sep?: unknown,
): Promise<unknown>;
export function join(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("join", ...args);
}

/**
 * This parses a JSON formatted string and returns the equivalent
 * in Vim values.  See `json_encode()` for the relation between
 * JSON and Vim values.
 * The decoding is permissive:
 * - A trailing comma in an array and object is ignored, e.g.
 *   "[1, 2, ]" is the same as "[1, 2]".
 * - Integer keys are accepted in objects, e.g. **{1:2}** is the
 *   same as **{"1":2}**.
 * - More floating point numbers are recognized, e.g. "1." for
 *   "1.0", or "001.2" for "1.2". Special floating point values
 *   "Infinity", "-Infinity" and "NaN" (capitalization ignored)
 *   are accepted.
 * - Leading zeroes in integer numbers are ignored, e.g. "012"
 *   for "12" or "-012" for "-12".
 * - Capitalization is ignored in literal names null, true or
 *   false, e.g. "NULL" for "null", "True" for "true".
 * - Control characters U+0000 through U+001F which are not
 *   escaped in strings are accepted, e.g. "       " (tab
 *   character in string) for "\t".
 * - An empty JSON expression or made of only spaces is accepted
 *   and results in v:none.
 * - Backslash in an invalid 2-character sequence escape is
 *   ignored, e.g. "\a" is decoded as "a".
 * - A correct surrogate pair in JSON strings should normally be
 *   a 12 character sequence such as "\uD834\uDD1E", but
 *   json_decode() silently accepts truncated surrogate pairs
 *   such as "\uD834" or "\uD834\u"
 *
 * A duplicate key in an object, valid in rfc7159, is not
 * accepted by json_decode() as the result must be a valid Vim
 * type, e.g. this fails: {"a":"b", "a":"c"}
 *
 * Can also be used as a `method`:
 *
 *     ReadObject()->json_decode()
 */
export function json_decode(denops: Denops, string: unknown): Promise<unknown>;
export function json_decode(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("json_decode", ...args);
}

/**
 * Encode **{expr}** as JSON and return this as a string.
 * The encoding is specified in:
 * https://tools.ietf.org/html/rfc7159.html
 * Vim values are converted as follows:
 *    `Number`             decimal number
 *    `Float`              floating point number
 *    Float nan            "NaN"
 *    Float inf            "Infinity"
 *    Float -inf           "-Infinity"
 *    `String`             in double quotes (possibly null)
 *    `Funcref`            not possible, error
 *    `List`               as an array (possibly null); when
 *                         used recursively: []
 *    `Dict`               as an object (possibly null); when
 *                         used recursively: {}
 *    `Blob`               as an array of the individual bytes
 *    v:false              "false"
 *    v:true               "true"
 *    v:none               "null"
 *    v:null               "null"
 * Note that NaN and Infinity are passed on as values.  This is
 * missing in the JSON standard, but several implementations do
 * allow it.  If not then you will get an error.
 * If a string contains an illegal character then the replacement
 * character 0xfffd is used.
 *
 * Can also be used as a `method`:
 *
 *     GetObject()->json_encode()
 */
export function json_encode(denops: Denops, expr: unknown): Promise<unknown>;
export function json_encode(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("json_encode", ...args);
}

/**
 * Return a `List` with all the keys of **{dict}**.  The `List` is in
 * arbitrary order.  Also see `items()` and `values()`.
 *
 * Can also be used as a `method`:
 *
 *     mydict->keys()
 */
export function keys(denops: Denops, dict: unknown): Promise<unknown>;
export function keys(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("keys", ...args);
}

/**
 * Turn the internal byte representation of keys into a form that
 * can be used for `:map`.  E.g.
 *
 *     :let xx = "\<C-Home>"
 *     :echo keytrans(xx)
 *
 *         `<C-Home>`
 *
 * Can also be used as a `method`:
 *
 *     "\<C-Home>"->keytrans()
 */
export function keytrans(denops: Denops, string: unknown): Promise<unknown>;
export function keytrans(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("keytrans", ...args);
}

/**
 * The result is a Number, which is the length of the argument.
 * When **{expr}** is a String or a Number the length in bytes is
 * used, as with `strlen()`.
 * When **{expr}** is a `List` the number of items in the `List` is
 * returned.
 * When **{expr}** is a `Blob` the number of bytes is returned.
 * When **{expr}** is a `Dictionary` the number of entries in the
 * `Dictionary` is returned.
 * Otherwise an error is given and returns zero.
 *
 * Can also be used as a `method`:
 *
 *     mylist->len()
 */
export function len(denops: Denops, expr: unknown): Promise<unknown>;
export function len(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("len", ...args);
}

/**
 * Call function **{funcname}** in the run-time library **{libname}**
 * with single argument **{argument}**.
 * This is useful to call functions in a library that you
 * especially made to be used with Vim.  Since only one argument
 * is possible, calling standard library functions is rather
 * limited.
 * The result is the String returned by the function.  If the
 * function returns NULL, this will appear as an empty string ""
 * to Vim.
 * If the function returns a number, use libcallnr()!
 * If **{argument}** is a number, it is passed to the function as an
 * int; if **{argument}** is a string, it is passed as a
 * null-terminated string.
 * This function will fail in `restricted-mode`.
 *
 * libcall() allows you to write your own 'plug-in' extensions to
 * Vim without having to recompile the program.  It is NOT a
 * means to call system functions!  If you try to do so Vim will
 * very probably crash.
 *
 * For Win32, the functions you write must be placed in a DLL
 * and use the normal C calling convention (NOT Pascal which is
 * used in Windows System DLLs).  The function must take exactly
 * one parameter, either a character pointer or a long integer,
 * and must return a character pointer or NULL.  The character
 * pointer returned must point to memory that will remain valid
 * after the function has returned (e.g. in static data in the
 * DLL).  If it points to allocated memory, that memory will
 * leak away.  Using a static buffer in the function should work,
 * it's then freed when the DLL is unloaded.
 *
 * WARNING: If the function returns a non-valid pointer, Vim may
 * crash!  This also happens if the function returns a number,
 * because Vim thinks it's a pointer.
 * For Win32 systems, **{libname}** should be the filename of the DLL
 * without the ".DLL" suffix.  A full path is only required if
 * the DLL is not in the usual places.
 * For Unix: When compiling your own plugins, remember that the
 * object code must be compiled as position-independent ('PIC').
 * *only in Win32 and some Unix versions, when the `+libcall`
 * feature is present*
 * Examples:
 *
 *     :echo libcall("libc.so", "getenv", "HOME")
 *
 * Can also be used as a `method`, the base is passed as the
 * third argument:
 *
 *     GetValue()->libcall("libc.so", "getenv")
 */
export function libcall(
  denops: Denops,
  libname: unknown,
  funcname: unknown,
  argument: unknown,
): Promise<unknown>;
export function libcall(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("libcall", ...args);
}

/**
 * Just like `libcall()`, but used for a function that returns an
 * int instead of a string.
 * *only in Win32 on some Unix versions, when the `+libcall`
 * feature is present*
 * Examples:
 *
 *     :echo libcallnr("/usr/lib/libc.so", "getpid", "")
 *     :call libcallnr("libc.so", "printf", "Hello World!\n")
 *     :call libcallnr("libc.so", "sleep", 10)
 *
 * Can also be used as a `method`, the base is passed as the
 * third argument:
 *
 *     GetValue()->libcallnr("libc.so", "printf")
 */
export function libcallnr(
  denops: Denops,
  libname: unknown,
  funcname: unknown,
  argument: unknown,
): Promise<unknown>;
export function libcallnr(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("libcallnr", ...args);
}

/**
 * Get the amount of indent for line **{lnum}** according the lisp
 * indenting rules, as with 'lisp'.
 * The indent is counted in spaces, the value of 'tabstop' is
 * relevant.  **{lnum}** is used just like in `getline()`.
 * When **{lnum}** is invalid -1 is returned.  In `Vim9` script an
 * error is given.
 *
 * Can also be used as a `method`:
 *
 *     GetLnum()->lispindent()
 */
export function lispindent(denops: Denops, lnum: unknown): Promise<unknown>;
export function lispindent(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("lispindent", ...args);
}

/**
 * Convert each number in **{list}** to a character string can
 * concatenate them all.  Examples:
 *
 *     list2str([32])          returns " "
 *     list2str([65, 66, 67])  returns "ABC"
 *
 * The same can be done (slowly) with:
 *
 *     join(map(list, {nr, val -> nr2char(val)}), '')
 *
 * `str2list()` does the opposite.
 *
 * When **{utf8}** is omitted or zero, the current 'encoding' is used.
 * When **{utf8}** is TRUE, always return UTF-8 characters.
 * With UTF-8 composing characters work as expected:
 *
 *     list2str([97, 769])     returns "á"
 *
 * Returns an empty string on error.
 *
 * Can also be used as a `method`:
 *
 *     GetList()->list2str()
 */
export function list2str(
  denops: Denops,
  list: unknown,
  utf8?: unknown,
): Promise<unknown>;
export function list2str(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("list2str", ...args);
}

/**
 * Return the current time, measured as seconds since 1st Jan
 * 1970.  See also `strftime()`, `strptime()` and `getftime()`.
 */
export function localtime(denops: Denops): Promise<unknown>;
export function localtime(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("localtime", ...args);
}

/**
 * Return the natural logarithm (base e) of **{expr}** as a `Float`.
 * **{expr}** must evaluate to a `Float` or a `Number` in the range
 * (0, inf].
 * Returns 0.0 if **{expr}** is not a `Float` or a `Number`.
 * Examples:
 *
 *     :echo log(10)
 *
 *         2.302585
 *
 *     :echo log(exp(5))
 *
 *         5.0
 *
 * Can also be used as a `method`:
 *
 *     Compute()->log()
 *
 * *only available when compiled with the `+float` feature*
 */
export function log(denops: Denops, expr: unknown): Promise<unknown>;
export function log(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("log", ...args);
}

/**
 * Return the logarithm of Float **{expr}** to base 10 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:
 *
 *     :echo log10(1000)
 *
 *         3.0
 *
 *     :echo log10(0.01)
 *
 *         -2.0
 *
 * Can also be used as a `method`:
 *
 *     Compute()->log10()
 *
 * *only available when compiled with the `+float` feature*
 */
export function log10(denops: Denops, expr: unknown): Promise<unknown>;
export function log10(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("log10", ...args);
}

/**
 * **{expr1}** must be a `List`, `String`, `Blob` or `Dictionary`.
 * When **{expr1}** is a `List` or `Dictionary`, replace each
 * item in **{expr1}** with the result of evaluating **{expr2}**.
 * For a `Blob` each byte is replaced.
 * For a `String`, each character, including composing
 * characters, is replaced.
 * If the item type changes you may want to use `mapnew()` to
 * create a new List or Dictionary.  This is required when using
 * Vim9 script.
 *
 * **{expr2}** must be a `String` or `Funcref`.
 *
 * If **{expr2}** is a `String`, inside **{expr2}** `v:val` has the value
 * of the current item.  For a `Dictionary` `v:key` has the key
 * of the current item and for a `List` `v:key` has the index of
 * the current item.  For a `Blob` `v:key` has the index of the
 * current byte. For a `String` `v:key` has the index of the
 * current character.
 * Example:
 *
 *     :call map(mylist, '"> " .. v:val .. " <"')
 *
 * This puts "> " before and " <" after each item in "mylist".
 *
 * Note that **{expr2}** is the result of an expression and is then
 * used as an expression again.  Often it is good to use a
 * `literal-string` to avoid having to double backslashes.  You
 * still have to double ' quotes
 *
 * If **{expr2}** is a `Funcref` it is called with two arguments:
 *         1. The key or the index of the current item.
 *         2. the value of the current item.
 * The function must return the new value of the item. Example
 * that changes each value by "key-value":
 *
 *     func KeyValue(key, val)
 *       return a:key .. '-' .. a:val
 *     endfunc
 *     call map(myDict, function('KeyValue'))
 *
 * It is shorter when using a `lambda`:
 *
 *     call map(myDict, {key, val -> key .. '-' .. val})
 *
 * If you do not use "val" you can leave it out:
 *
 *     call map(myDict, {key -> 'item: ' .. key})
 *
 * If you do not use "key" you can use a short name:
 *
 *     call map(myDict, {_, val -> 'item: ' .. val})
 *
 * The operation is done in-place for a `List` and `Dictionary`.
 * If you want it to remain unmodified make a copy first:
 *
 *     :let tlist = map(copy(mylist), ' v:val .. "\t"')
 *
 * Returns **{expr1}**, the `List` or `Dictionary` that was filtered,
 * or a new `Blob` or `String`.
 * When an error is encountered while evaluating **{expr2}** no
 * further items in **{expr1}** are processed.
 * When **{expr2}** is a Funcref errors inside a function are ignored,
 * unless it was defined with the "abort" flag.
 *
 * Can also be used as a `method`:
 *
 *     mylist->map(expr2)
 */
export function map(
  denops: Denops,
  expr1: unknown,
  expr2: unknown,
): Promise<unknown>;
export function map(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("map", ...args);
}

/**
 * When **{dict}** is omitted or zero: Return the rhs of mapping
 * **{name}** in mode **{mode}**.  The returned String has special
 * characters translated like in the output of the ":map" command
 * listing. When **{dict}** is TRUE a dictionary is returned, see
 * below. To get a list of all mappings see `maplist()`.
 *
 * When there is no mapping for **{name}**, an empty String is
 * returned if **{dict}** is FALSE, otherwise returns an empty Dict.
 * When the mapping for **{name}** is empty, then `"<Nop>"` is
 * returned.
 *
 * The **{name}** can have special key names, like in the ":map"
 * command.
 *
 * **{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
 *         "l"     langmap `language-mapping`
 *         "t"     Terminal-Job
 *         ""      Normal, Visual and Operator-pending
 * When **{mode}** is omitted, the modes for "" are used.
 *
 * When **{abbr}** is there and it is `TRUE` use abbreviations
 * instead of mappings.
 *
 * When **{dict}** is there and it is `TRUE` return a dictionary
 * containing all the information of the mapping with the
 * following items:
 *   "lhs"      The **{lhs}** of the mapping as it would be typed
 *   "lhsraw"   The **{lhs}** of the mapping as raw bytes
 *   "lhsrawalt" The **{lhs}** of the mapping as raw bytes, alternate
 *               form, only present when it differs from "lhsraw"
 *   "rhs"      The **{rhs}** of the mapping as typed.
 *   "silent"   1 for a `:map-silent` mapping, else 0.
 *   "noremap"  1 if the **{rhs}** of the mapping is not remappable.
 *   "script"   1 if mapping was defined with `<script>`.
 *   "expr"     1 for an expression mapping (`:map-<expr>`).
 *   "buffer"   1 for a buffer local mapping (`:map-local`).
 *   "mode"     Modes for which the mapping is defined. In
 *              addition to the modes mentioned above, these
 *              characters will be used:
 *              " "     Normal, Visual and Operator-pending
 *              "!"     Insert and Commandline mode
 *                      (`mapmode-ic`)
 *   "sid"      The script local ID, used for `<sid>` mappings
 *              (`<SID>`).
 *   "scriptversion"  The version of the script.  999999 for
 *                    `Vim9` script.
 *   "lnum"     The line number in "sid", zero if unknown.
 *   "nowait"   Do not wait for other, longer mappings.
 *              (`:map-<nowait>`).
 *   "abbr"     True if this is an abbreviation `abbreviations`.
 *   "mode_bits" Vim's internal binary representation of "mode".
 *              `mapset()` ignores this; only "mode" is used.
 *              See `maplist()` for usage examples. The values
 *              are from src/vim.h and may change in the future.
 *
 * The dictionary can be used to restore a mapping with
 * `mapset()`.
 *
 * The mappings local to the current buffer are checked first,
 * then the global mappings.
 * This function can be used to map a key even when it's already
 * mapped, and have it do the original mapping too.  Sketch:
 *
 *     exe 'nnoremap <Tab> ==' .. maparg('<Tab>', 'n')
 *
 * Can also be used as a `method`:
 *
 *     GetKey()->maparg('n')
 */
export function maparg(
  denops: Denops,
  name: unknown,
  mode?: unknown,
  abbr?: unknown,
  dict?: unknown,
): Promise<unknown>;
export function maparg(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("maparg", ...args);
}

/**
 * Check if there is a mapping that matches with **{name}** in mode
 * **{mode}**.  See `maparg()` for **{mode}** and special names in
 * **{name}**.
 * When **{abbr}** is there and it is `TRUE` use abbreviations
 * instead of mappings.
 * A match happens with a mapping that starts with **{name}** and
 * with a mapping which is equal to the start of **{name}**.
 *
 *         matches mapping "a"     "ab"    "abc"
 *    mapcheck("a")        yes     yes      yes
 *    mapcheck("abc")      yes     yes      yes
 *    mapcheck("ax")       yes     no       no
 *    mapcheck("b")        no      no       no
 *
 * The difference with maparg() is that mapcheck() finds a
 * mapping that matches with **{name}**, while maparg() only finds a
 * mapping for **{name}** exactly.
 * When there is no mapping that starts with **{name}**, an empty
 * String is returned.  If there is one, the RHS of that mapping
 * is returned.  If there are several mappings that start with
 * **{name}**, the RHS of one of them is returned.  This will be
 * `"<Nop>"` if the RHS is empty.
 * The mappings local to the current buffer are checked first,
 * then the global mappings.
 * This function can be used to check if a mapping can be added
 * without being ambiguous.  Example:
 *
 *     :if mapcheck("_vv") == ""
 *     :   map _vv :set guifont=7x13<CR>
 *     :endif
 *
 * This avoids adding the "_vv" mapping when there already is a
 * mapping for "_v" or for "_vvv".
 *
 * Can also be used as a `method`:
 *
 *     GetKey()->mapcheck('n')
 */
export function mapcheck(
  denops: Denops,
  name: unknown,
  mode?: unknown,
  abbr?: unknown,
): Promise<unknown>;
export function mapcheck(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("mapcheck", ...args);
}

/**
 * Restore a mapping from a dictionary, possibly returned by
 * `maparg()` or `maplist()`.  A buffer mapping, when dict.buffer
 * is true, is set on the current buffer; it is up to the caller
 * to ensure that the intended buffer is the current buffer. This
 * feature allows copying mappings from one buffer to another.
 * The dict.mode value may restore a single mapping that covers
 * more than one mode, like with mode values of '!', ' ', 'nox',
 * or 'v'.
 *
 * In the first form, **{mode}** and **{abbr}** should be the same as
 * for the call to `maparg()`.
 * **{mode}** is used to define the mode in which the mapping is set,
 * not the "mode" entry in **{dict}**.
 * Example for saving and restoring a mapping:
 *
 *     let save_map = maparg('K', 'n', 0, 1)
 *     nnoremap K somethingelse
 *     ...
 *     call mapset('n', 0, save_map)
 *
 * Note that if you are going to replace a map in several modes,
 * e.g. with `:map!`, you need to save/restore the mapping for
 * all of them, when they might differ.
 *
 * In the second form, with **{dict}** as the only argument, mode
 * and abbr are taken from the dict.
 * Example:
 *
 *     vim9script
 *     var save_maps = maplist()->filter(
 *                             (_, m) => m.lhs == 'K')
 *     nnoremap K somethingelse
 *     cnoremap K somethingelse2
 *     # ...
 *     unmap K
 *     for d in save_maps
 *         mapset(d)
 *     endfor
 */
export function mapset(
  denops: Denops,
  mode: unknown,
  abbr: unknown,
  dict: unknown,
): Promise<unknown>;
export function mapset(denops: Denops, dict: unknown): Promise<unknown>;
export function mapset(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("mapset", ...args);
}

/**
 * When **{expr}** is a `List` then this returns the index of the
 * first item where **{pat}** matches.  Each item is used as a
 * String, `Lists` and `Dictionaries` are used as echoed.
 *
 * Otherwise, **{expr}** is used as a String.  The result is a
 * Number, which gives the index (byte offset) in **{expr}** where
 * **{pat}** matches.
 *
 * A match at the first character or `List` item returns zero.
 * If there is no match -1 is returned.
 *
 * For getting submatches see `matchlist()`.
 * Example:
 *
 *     :echo match("testing", "ing")   " results in 4
 *     :echo match([1, 'x'], '\a')     " results in 1
 *
 * See `string-match` for how **{pat}** is used.
 *
 * Vim doesn't have a strpbrk() function.  But you can do:
 *
 *     :let sepidx = match(line, '[.,;: \t]')
 *
 * Vim doesn't have a strcasestr() function.  But you can add
 * "\c" to the pattern to ignore case:
 *
 *     :let idx = match(haystack, '\cneedle')
 *
 * If **{start}** is given, the search starts from byte index
 * **{start}** in a String or item **{start}** in a `List`.
 * The result, however, is still the index counted from the
 * first character/item.  Example:
 *
 *     :echo match("testing", "ing", 2)
 *
 * result is again "4".
 *
 *     :echo match("testing", "ing", 4)
 *
 * result is again "4".
 *
 *     :echo match("testing", "t", 2)
 *
 * result is "3".
 * For a String, if **{start}** > 0 then it is like the string starts
 * **{start}** bytes later, thus "^" will match at **{start}**.  Except
 * when **{count}** is given, then it's like matches before the
 * **{start}** byte are ignored (this is a bit complicated to keep it
 * backwards compatible).
 * For a String, if **{start}** < 0, it will be set to 0.  For a list
 * the index is counted from the end.
 * If **{start}** is out of range (**{start}** > strlen(**{expr}**) for a
 * String or **{start}** > len(**{expr}**) for a `List`) -1 is returned.
 *
 * When **{count}** is given use the **{count}**'th match.  When a match
 * is found in a String the search for the next one starts one
 * character further.  Thus this example results in 1:
 *
 *     echo match("testing", "..", 0, 2)
 *
 * In a `List` the search continues in the next item.
 * Note that when **{count}** is added the way **{start}** works changes,
 * see above.
 *
 * See `pattern` for the patterns that are accepted.
 * The 'ignorecase' option is used to set the ignore-caseness of
 * the pattern.  'smartcase' is NOT used.  The matching is always
 * done like 'magic' is set and 'cpoptions' is empty.
 * Note that a match at the start is preferred, thus when the
 * pattern is using "*" (any number of matches) it tends to find
 * zero matches at the start instead of a number of matches
 * further down in the text.
 *
 * Can also be used as a `method`:
 *
 *     GetText()->match('word')
 *     GetList()->match('word')
 */
export function match(
  denops: Denops,
  expr: unknown,
  pat: unknown,
  start?: unknown,
  count?: unknown,
): Promise<unknown>;
export function match(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("match", ...args);
}

/**
 * Defines a pattern to be highlighted in the current window (a
 * "match").  It will be highlighted with **{group}**.  Returns an
 * identification number (ID), which can be used to delete the
 * match using `matchdelete()`.  The ID is bound to the window.
 * Matching is case sensitive and magic, unless case sensitivity
 * or magicness are explicitly overridden in **{pattern}**.  The
 * 'magic', 'smartcase' and 'ignorecase' options are not used.
 * The "Conceal" value is special, it causes the match to be
 * concealed.
 *
 * The optional **{priority}** argument assigns a priority to the
 * match.  A match with a high priority will have its
 * highlighting overrule that of a match with a lower priority.
 * A priority is specified as an integer (negative numbers are no
 * exception).  If the **{priority}** argument is not specified, the
 * default priority is 10.  The priority of 'hlsearch' is zero,
 * hence all matches with a priority greater than zero will
 * overrule it.  Syntax highlighting (see 'syntax') is a separate
 * mechanism, and regardless of the chosen priority a match will
 * always overrule syntax highlighting.
 *
 * The optional **{id}** argument allows the request for a specific
 * match ID.  If a specified ID is already taken, an error
 * message will appear and the match will not be added.  An ID
 * is specified as a positive integer (zero excluded).  IDs 1, 2
 * and 3 are reserved for `:match`, `:2match` and `:3match`,
 * respectively.  3 is reserved for use by the `matchparen`
 * plugin.
 * If the **{id}** argument is not specified or -1, `matchadd()`
 * automatically chooses a free ID.
 *
 * The optional **{dict}** argument allows for further custom
 * values. Currently this is used to specify a match specific
 * conceal character that will be shown for `hl-Conceal`
 * highlighted matches. The dict can have the following members:
 *
 *         conceal     Special character to show instead of the
 *                     match (only for `hl-Conceal` highlighted
 *                     matches, see `:syn-cchar`)
 *         window      Instead of the current window use the
 *                     window with this number or window ID.
 *
 * The number of matches is not limited, as it is the case with
 * the `:match` commands.
 *
 * Returns -1 on error.
 *
 * Example:
 *
 *     :highlight MyGroup ctermbg=green guibg=green
 *     :let m = matchadd("MyGroup", "TODO")
 *
 * Deletion of the pattern:
 *
 *     :call matchdelete(m)
 *
 * A list of matches defined by `matchadd()` and `:match` are
 * available from `getmatches()`.  All matches can be deleted in
 * one operation by `clearmatches()`.
 *
 * Can also be used as a `method`:
 *
 *     GetGroup()->matchadd('TODO')
 */
export function matchadd(
  denops: Denops,
  group: unknown,
  pattern: unknown,
  priority?: unknown,
  id?: unknown,
  dict?: unknown,
): Promise<unknown>;
export function matchadd(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("matchadd", ...args);
}

/**
 * Same as `matchadd()`, but requires a list of positions **{pos}**
 * instead of a pattern. This command is faster than `matchadd()`
 * because it does not require to handle regular expressions and
 * sets buffer line boundaries to redraw screen. It is supposed
 * to be used when fast match additions and deletions are
 * required, for example to highlight matching parentheses.
 *
 * **{pos}** is a list of positions.  Each position can be one of
 * these:
 * - A number.  This whole line will be highlighted.  The first
 *   line has number 1.
 * - A list with one number, e.g., [23]. The whole line with this
 *   number will be highlighted.
 * - A list with two numbers, e.g., [23, 11]. The first number is
 *   the line number, the second one is the column number (first
 *   column is 1, the value must correspond to the byte index as
 *   `col()` would return).  The character at this position will
 *   be highlighted.
 * - A list with three numbers, e.g., [23, 11, 3]. As above, but
 *   the third number gives the length of the highlight in bytes.
 *
 * The maximum number of positions in **{pos}** is 8.
 *
 * Returns -1 on error.
 *
 * Example:
 *
 *     :highlight MyGroup ctermbg=green guibg=green
 *     :let m = matchaddpos("MyGroup", [[23, 24], 34])
 *
 * Deletion of the pattern:
 *
 *     :call matchdelete(m)
 *
 * Matches added by `matchaddpos()` are returned by
 * `getmatches()`.
 *
 * Can also be used as a `method`:
 *
 *     GetGroup()->matchaddpos([23, 11])
 */
export function matchaddpos(
  denops: Denops,
  group: unknown,
  pos: unknown,
  priority?: unknown,
  id?: unknown,
  dict?: unknown,
): Promise<unknown>;
export function matchaddpos(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("matchaddpos", ...args);
}

/**
 * Selects the **{nr}** match item, as set with a `:match`,
 * `:2match` or `:3match` command.
 * Return a `List` with two elements:
 *         The name of the highlight group used
 *         The pattern used.
 * When **{nr}** is not 1, 2 or 3 returns an empty `List`.
 * When there is no match item set returns ['', ''].
 * This is useful to save and restore a `:match`.
 * Highlighting matches using the `:match` commands are limited
 * to three matches. `matchadd()` does not have this limitation.
 *
 * Can also be used as a `method`:
 *
 *     GetMatch()->matcharg()
 */
export function matcharg(denops: Denops, nr: unknown): Promise<unknown>;
export function matcharg(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("matcharg", ...args);
}

/**
 * Deletes a match with ID **{id}** previously defined by `matchadd()`
 * or one of the `:match` commands.  Returns 0 if successful,
 * otherwise -1.  See example for `matchadd()`.  All matches can
 * be deleted in one operation by `clearmatches()`.
 * 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`:
 *
 *     GetMatch()->matchdelete()
 */
export function matchdelete(
  denops: Denops,
  id: unknown,
  win?: unknown,
): Promise<unknown>;
export function matchdelete(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("matchdelete", ...args);
}

/**
 * Same as `match()`, but return the index of first character
 * after the match.  Example:
 *
 *     :echo matchend("testing", "ing")
 *
 * results in "7".
 *
 * Vim doesn't have a strspn() or strcspn() function, but you can
 * do it with matchend():
 *
 *     :let span = matchend(line, '[a-zA-Z]')
 *     :let span = matchend(line, '[^a-zA-Z]')
 *
 * Except that -1 is returned when there are no matches.
 *
 * The **{start}**, if given, has the same meaning as for `match()`.
 *
 *     :echo matchend("testing", "ing", 2)
 *
 * results in "7".
 *
 *     :echo matchend("testing", "ing", 5)
 *
 * result is "-1".
 * When **{expr}** is a `List` the result is equal to `match()`.
 *
 * Can also be used as a `method`:
 *
 *     GetText()->matchend('word')
 */
export function matchend(
  denops: Denops,
  expr: unknown,
  pat: unknown,
  start?: unknown,
  count?: unknown,
): Promise<unknown>;
export function matchend(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("matchend", ...args);
}

/**
 * If **{list}** is a list of strings, then returns a `List` with all
 * the strings in **{list}** that fuzzy match **{str}**. The strings in
 * the returned list are sorted based on the matching score.
 *
 * The optional **{dict}** argument always supports the following
 * items:
 *     matchseq    When this item is present return only matches
 *                 that contain the characters in **{str}** in the
 *                 given sequence.
 *     limit       Maximum number of matches in **{list}** to be
 *                 returned.  Zero means no limit.
 *
 * If **{list}** is a list of dictionaries, then the optional **{dict}**
 * argument supports the following additional items:
 *     key         Key of the item which is fuzzy matched against
 *                 **{str}**. The value of this item should be a
 *                 string.
 *     text_cb     `Funcref` that will be called for every item
 *                 in **{list}** to get the text for fuzzy matching.
 *                 This should accept a dictionary item as the
 *                 argument and return the text for that item to
 *                 use for fuzzy matching.
 *
 * **{str}** is treated as a literal string and regular expression
 * matching is NOT supported.  The maximum supported **{str}** length
 * is 256.
 *
 * When **{str}** has multiple words each separated by white space,
 * then the list of strings that have all the words is returned.
 *
 * If there are no matching strings or there is an error, then an
 * empty list is returned. If length of **{str}** is greater than
 * 256, then returns an empty list.
 *
 * When **{limit}** is given, matchfuzzy() will find up to this
 * number of matches in **{list}** and return them in sorted order.
 *
 * Refer to `fuzzy-matching` for more information about fuzzy
 * matching strings.
 *
 * Example:
 *
 *     :echo matchfuzzy(["clay", "crow"], "cay")
 *
 * results in ["clay"].
 *
 *     :echo getbufinfo()->map({_, v -> v.name})->matchfuzzy("ndl")
 *
 * results in a list of buffer names fuzzy matching "ndl".
 *
 *     :echo getbufinfo()->matchfuzzy("ndl", {'key' : 'name'})
 *
 * results in a list of buffer information dicts with buffer
 * names fuzzy matching "ndl".
 *
 *     :echo getbufinfo()->matchfuzzy("spl",
 *                                  \ {'text_cb' : {v -> v.name}})
 *
 * results in a list of buffer information dicts with buffer
 * names fuzzy matching "spl".
 *
 *     :echo v:oldfiles->matchfuzzy("test")
 *
 * results in a list of file names fuzzy matching "test".
 *
 *     :let l = readfile("buffer.c")->matchfuzzy("str")
 *
 * results in a list of lines in "buffer.c" fuzzy matching "str".
 *
 *     :echo ['one two', 'two one']->matchfuzzy('two one')
 *
 * results in ['two one', 'one two'].
 *
 *     :echo ['one two', 'two one']->matchfuzzy('two one',
 *                                  \ {'matchseq': 1})
 *
 * results in ['two one'].
 */
export function matchfuzzy(
  denops: Denops,
  list: unknown,
  str: unknown,
  dict?: unknown,
): Promise<unknown>;
export function matchfuzzy(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("matchfuzzy", ...args);
}

/**
 * Same as `matchfuzzy()`, but returns the list of matched
 * strings, the list of character positions where characters
 * in **{str}** matches and a list of matching scores.  You can
 * use `byteidx()` to convert a character position to a byte
 * position.
 *
 * If **{str}** matches multiple times in a string, then only the
 * positions for the best match is returned.
 *
 * If there are no matching strings or there is an error, then a
 * list with three empty list items is returned.
 *
 * Example:
 *
 *     :echo matchfuzzypos(['testing'], 'tsg')
 *
 * results in [['testing'], [[0, 2, 6]], [99]]
 *
 *     :echo matchfuzzypos(['clay', 'lacy'], 'la')
 *
 * results in [['lacy', 'clay'], [[0, 1], [1, 2]], [153, 133]]
 *
 *     :echo [{'text': 'hello', 'id' : 10}]->matchfuzzypos('ll', {'key' : 'text'})
 *
 * results in [[{'id': 10, 'text': 'hello'}], [[2, 3]], [127]]
 */
export function matchfuzzypos(
  denops: Denops,
  list: unknown,
  str: unknown,
  dict?: unknown,
): Promise<unknown>;
export function matchfuzzypos(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("matchfuzzypos", ...args);
}

/**
 * Same as `match()`, but return a `List`.  The first item in the
 * list is the matched string, same as what matchstr() would
 * return.  Following items are submatches, like "\1", "\2", etc.
 * in `:substitute`.  When an optional submatch didn't match an
 * empty string is used.  Example:
 *
 *     echo matchlist('acd', '\(a\)\?\(b\)\?\(c\)\?\(.*\)')
 *
 * Results in: ['acd', 'a', '', 'c', 'd', '', '', '', '', '']
 * When there is no match an empty list is returned.
 *
 * You can pass in a List, but that is not very useful.
 *
 * Can also be used as a `method`:
 *
 *     GetText()->matchlist('word')
 */
export function matchlist(
  denops: Denops,
  expr: unknown,
  pat: unknown,
  start?: unknown,
  count?: unknown,
): Promise<unknown>;
export function matchlist(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("matchlist", ...args);
}

/**
 * Same as `match()`, but return the matched string.  Example:
 *
 *     :echo matchstr("testing", "ing")
 *
 * results in "ing".
 * When there is no match "" is returned.
 * The **{start}**, if given, has the same meaning as for `match()`.
 *
 *     :echo matchstr("testing", "ing", 2)
 *
 * results in "ing".
 *
 *     :echo matchstr("testing", "ing", 5)
 *
 * result is "".
 * When **{expr}** is a `List` then the matching item is returned.
 * The type isn't changed, it's not necessarily a String.
 *
 * Can also be used as a `method`:
 *
 *     GetText()->matchstr('word')
 */
export function matchstr(
  denops: Denops,
  expr: unknown,
  pat: unknown,
  start?: unknown,
  count?: unknown,
): Promise<unknown>;
export function matchstr(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("matchstr", ...args);
}

/**
 * Same as `matchstr()`, but return the matched string, the start
 * position and the end position of the match.  Example:
 *
 *     :echo matchstrpos("testing", "ing")
 *
 * results in ["ing", 4, 7].
 * When there is no match ["", -1, -1] is returned.
 * The **{start}**, if given, has the same meaning as for `match()`.
 *
 *     :echo matchstrpos("testing", "ing", 2)
 *
 * results in ["ing", 4, 7].
 *
 *     :echo matchstrpos("testing", "ing", 5)
 *
 * result is ["", -1, -1].
 * When **{expr}** is a `List` then the matching item, the index
 * of first item where **{pat}** matches, the start position and the
 * end position of the match are returned.
 *
 *     :echo matchstrpos([1, '__x'], '\a')
 *
 * result is ["x", 1, 2, 3].
 * The type isn't changed, it's not necessarily a String.
 *
 * Can also be used as a `method`:
 *
 *     GetText()->matchstrpos('word')
 */
export function matchstrpos(
  denops: Denops,
  expr: unknown,
  pat: unknown,
  start?: unknown,
  count?: unknown,
): Promise<unknown>;
export function matchstrpos(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("matchstrpos", ...args);
}

/**
 * Return the maximum value of all items in **{expr}**. Example:
 *
 *     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`:
 *
 *     mylist->max()
 */
export function max(denops: Denops, expr: unknown): Promise<unknown>;
export function max(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("max", ...args);
}

/**
 * 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:
 *
 *     :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`:
 *
 *     GetMenuName()->menu_info('v')
 */
export function menu_info(
  denops: Denops,
  name: unknown,
  mode?: unknown,
): Promise<unknown>;
export function menu_info(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("menu_info", ...args);
}

/**
 * Return the minimum value of all items in **{expr}**. Example:
 *
 *     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`:
 *
 *     mylist->min()
 */
export function min(denops: Denops, expr: unknown): Promise<unknown>;
export function min(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("min", ...args);
}

/**
 * Create directory **{name}**.
 *
 * If **{path}** contains "p" then intermediate directories are
 * created as necessary.  Otherwise it must be "".
 *
 * If **{path}** contains "D" then **{name}** is deleted at the end of
 * the current function, as with:
 *
 *     defer delete({name}, 'd')
 *
 * If **{path}** contains "R" then **{name}** is deleted recursively at
 * the end of the current function, as with:
 *
 *     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:
 *
 *     call mkdir('subdir/tmp/autoload', 'pR')
 *
 * and "subdir" already exists then "subdir/tmp" will be
 * scheduled for deletion, like with:
 *
 *     defer delete('subdir/tmp', 'rf')
 *
 * Note that if scheduling the defer fails the directory is not
 * deleted.  This should only happen when out of memory.
 *
 * 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.  This is only used for the last part of
 * **{name}**.  Thus if you create /tmp/foo/bar then /tmp/foo will be
 * created with 0o755.
 * Example:
 *
 *     :call mkdir($HOME .. "/tmp/foo/bar", "p", 0o700)
 *
 * This function is not available in the `sandbox`.
 *
 * There is no error if the directory already exists and the "p"
 * flag is passed (since patch 8.0.1708).  However, without the
 * "p" option the call will fail.
 *
 * The function result is a Number, which is TRUE if the call was
 * successful or FALSE if the directory creation failed or partly
 * failed.
 *
 * Not available on all systems.  To check use:
 *
 *     :if exists("*mkdir")
 *
 * Can also be used as a `method`:
 *
 *     GetName()->mkdir()
 */
export function mkdir(
  denops: Denops,
  name: unknown,
  path?: unknown,
  prot?: unknown,
): Promise<unknown>;
export function mkdir(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("mkdir", ...args);
}

/**
 * Return the line number of the first line at or below **{lnum}**
 * that is not blank.  Example:
 *
 *     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`:
 *
 *     GetLnum()->nextnonblank()
 */
export function nextnonblank(denops: Denops, lnum: unknown): Promise<unknown>;
export function nextnonblank(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("nextnonblank", ...args);
}

/**
 * Return a string with a single character, which has the number
 * value **{expr}**.  Examples:
 *
 *     nr2char(64)             returns "@"
 *     nr2char(32)             returns " "
 *
 * When **{utf8}** is omitted or zero, the current 'encoding' is used.
 * Example for "utf-8":
 *
 *     nr2char(300)            returns I with bow character
 *
 * When **{utf8}** is TRUE, always return UTF-8 characters.
 * 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.
 * To turn a list of character numbers into a string:
 *
 *     let list = [65, 66, 67]
 *     let str = join(map(list, {_, val -> nr2char(val)}), '')
 *
 * Result: "ABC"
 *
 * Can also be used as a `method`:
 *
 *     GetNumber()->nr2char()
 */
export function nr2char(
  denops: Denops,
  expr: unknown,
  utf8?: unknown,
): Promise<unknown>;
export function nr2char(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("nr2char", ...args);
}

/**
 * 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:
 *
 *     :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.
 */
export function or(
  denops: Denops,
  expr1: unknown,
  expr2: unknown,
): Promise<unknown>;
export function or(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("or", ...args);
}

/**
 * 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:
 *
 *     :echo pathshorten('~/.vim/autoload/myfile.vim')
 *
 *         `~/.v/a/myfile.vim`
 *
 *     :echo pathshorten('~/.vim/autoload/myfile.vim', 2)
 *
 *         `~/.vi/au/myfile.vim`
 * It doesn't matter if the path exists or not.
 * Returns an empty string on error.
 *
 * Can also be used as a `method`:
 *
 *     GetDirectories()->pathshorten()
 */
export function pathshorten(
  denops: Denops,
  path: unknown,
  len?: unknown,
): Promise<unknown>;
export function pathshorten(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("pathshorten", ...args);
}

/**
 * Evaluate Perl expression **{expr}** in scalar context and return
 * its result converted to Vim data structures. If value can't be
 * converted, it is returned as a string Perl representation.
 * Note: If you want an array or hash, **{expr}** must return a
 * reference to it.
 * Example:
 *
 *     :echo perleval('[1 .. 4]')
 *
 *         [1, 2, 3, 4]
 *
 * Note that in a `:def` function local variables are not visible
 * to **{expr}**.
 *
 * Can also be used as a `method`:
 *
 *     GetExpr()->perleval()
 *
 * *only available when compiled with the `+perl` feature*
 */
export function perleval(denops: Denops, expr: unknown): Promise<unknown>;
export function perleval(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("perleval", ...args);
}

/**
 * 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:
 *
 *     :echo pow(3, 3)
 *
 *         27.0
 *
 *     :echo pow(2, 16)
 *
 *         65536.0
 *
 *     :echo pow(32, 0.20)
 *
 *         2.0
 *
 * Can also be used as a `method`:
 *
 *     Compute()->pow(3)
 *
 * *only available when compiled with the `+float` feature*
 */
export function pow(denops: Denops, x: unknown, y: unknown): Promise<unknown>;
export function pow(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("pow", ...args);
}

/**
 * Return the line number of the first line at or above **{lnum}**
 * that is not blank.  Example:
 *
 *     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`:
 *
 *     GetLnum()->prevnonblank()
 */
export function prevnonblank(denops: Denops, lnum: unknown): Promise<unknown>;
export function prevnonblank(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("prevnonblank", ...args);
}

/**
 * Return a String with **{fmt}**, where "%" items are replaced by
 * the formatted form of their respective arguments.  Example:
 *
 *     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:
 *
 *     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
 *   %x    hex number
 *   %04x  hex number padded with zeros to at least 4 characters
 *   %X    hex number using upper case letters
 *   %o    octal number
 *   %08b  binary number padded with zeros to at least 8 chars
 *   %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
 *
 * 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 b and B conversions, a non-zero result has
 *               the string "0b" (or "0B" for B conversions)
 *               prepended to it.
 *               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, b, B, 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:
 *
 *     :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:
 *
 *             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.
 */
export function printf(
  denops: Denops,
  fmt: unknown,
  expr1: unknown,
): Promise<unknown>;
export function printf(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("printf", ...args);
}

/**
 * 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`:
 *
 *     GetBuffer()->prompt_getprompt()
 *
 * *only available when compiled with the `+channel` feature*
 */
export function prompt_getprompt(
  denops: Denops,
  buf: unknown,
): Promise<unknown>;
export function prompt_getprompt(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("prompt_getprompt", ...args);
}

/**
 * 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:
 *
 *     call prompt_setcallback(bufnr(), function('s:TextEntered'))
 *     func s:TextEntered(text)
 *       if a:text == 'exit' || a:text == 'quit'
 *         stopinsert
 *         close
 *       else
 *         call append(line('$') - 1, 'Entered: "' .. a:text .. '"')
 *         " Reset 'modified' to allow the buffer to be closed.
 *         set nomodified
 *       endif
 *     endfunc
 *
 * Can also be used as a `method`:
 *
 *     GetBuffer()->prompt_setcallback(callback)
 *
 * *only available when compiled with the `+channel` feature*
 */
export function prompt_setcallback(
  denops: Denops,
  buf: unknown,
  expr: unknown,
): Promise<unknown>;
export function prompt_setcallback(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("prompt_setcallback", ...args);
}

/**
 * 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`:
 *
 *     GetBuffer()->prompt_setinterrupt(callback)
 *
 * *only available when compiled with the `+channel` feature*
 */
export function prompt_setinterrupt(
  denops: Denops,
  buf: unknown,
  expr: unknown,
): Promise<unknown>;
export function prompt_setinterrupt(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("prompt_setinterrupt", ...args);
}

/**
 * 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:
 *
 *     call prompt_setprompt(bufnr(), 'command: ')
 *
 * Can also be used as a `method`:
 *
 *     GetBuffer()->prompt_setprompt('command: ')
 *
 * *only available when compiled with the `+channel` feature*
 */
export function prompt_setprompt(
  denops: Denops,
  buf: unknown,
  text: unknown,
): Promise<unknown>;
export function prompt_setprompt(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("prompt_setprompt", ...args);
}

/**
 * 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`.
 */
export function pum_getpos(denops: Denops): Promise<unknown>;
export function pum_getpos(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("pum_getpos", ...args);
}

/**
 * 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.
 */
export function pumvisible(denops: Denops): Promise<unknown>;
export function pumvisible(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("pumvisible", ...args);
}

/**
 * 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
 * 'encoding').
 * Lists are represented as Vim `List` type.
 * Dictionaries are represented as Vim `Dictionary` type with
 * keys converted to strings.
 * Note that in a `:def` function local variables are not visible
 * to **{expr}**.
 *
 * Can also be used as a `method`:
 *
 *     GetExpr()->py3eval()
 *
 * *only available when compiled with the `+python3` feature*
 */
export function py3eval(denops: Denops, expr: unknown): Promise<unknown>;
export function py3eval(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("py3eval", ...args);
}

/**
 * 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.
 * Note that in a `:def` function local variables are not visible
 * to **{expr}**.
 *
 * Can also be used as a `method`:
 *
 *     GetExpr()->pyeval()
 *
 * *only available when compiled with the `+python` feature*
 */
export function pyeval(denops: Denops, expr: unknown): Promise<unknown>;
export function pyeval(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("pyeval", ...args);
}

/**
 * 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`:
 *
 *     GetExpr()->pyxeval()
 *
 * *only available when compiled with the `+python` or the
 * `+python3` feature*
 */
export function pyxeval(denops: Denops, expr: unknown): Promise<unknown>;
export function pyxeval(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("pyxeval", ...args);
}

/**
 * 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:
 *
 *     :echo rand()
 *     :let seed = srand()
 *     :echo rand(seed)
 *     :echo rand(seed) % 16  " random number 0 - 15
 */
export function rand(denops: Denops, expr?: unknown): Promise<unknown>;
export function rand(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("rand", ...args);
}

/**
 * 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:
 *
 *     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`:
 *
 *     GetExpr()->range()
 */
export function range(
  denops: Denops,
  expr: unknown,
  max?: unknown,
  stride?: unknown,
): Promise<unknown>;
export function range(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("range", ...args);
}

/**
 * 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.
 * The list will be sorted (case sensitive), see the **{dict}**
 * argument below for changing the sort order.
 *
 * 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.
 * The entries "." and ".." are always excluded.
 * 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":
 *
 *     readdir(dirname, {n -> n =~ '.txt$'})
 *
 * To skip hidden and backup files:
 *
 *     readdir(dirname, {n -> n !~ '^\.\|\~$'})
 *
 * The optional **{dict}** argument allows for further custom
 * values. Currently this is used to specify if and how sorting
 * should be performed. The dict can have the following members:
 *
 *     sort    How to sort the result returned from the system.
 *             Valid values are:
 *                 "none"      do not sort (fastest method)
 *                 "case"      sort case sensitive (byte value of
 *                             each character, technically, using
 *                             strcmp()) (default)
 *                 "icase"     sort case insensitive (technically
 *                             using strcasecmp())
 *                 "collate"   sort using the collation order
 *                             of the "POSIX" or "C" `locale`
 *                             (technically using strcoll())
 *             Other values are silently ignored.
 *
 * For example, to get a list of all files in the current
 * directory without sorting the individual entries:
 *
 *     readdir('.', '1', #{sort: 'none'})
 *
 * If you want to get a directory tree:
 *
 *     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`:
 *
 *     GetDirName()->readdir()
 */
export function readdir(
  denops: Denops,
  directory: unknown,
  expr?: unknown,
  dict?: unknown,
): Promise<unknown>;
export function readdir(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("readdir", ...args);
}

/**
 * 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.
 * - When 'encoding' is Unicode 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:
 *
 *     :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`:
 *
 *     GetFileName()->readfile()
 */
export function readfile(
  denops: Denops,
  fname: unknown,
  type?: unknown,
  max?: unknown,
): Promise<unknown>;
export function readfile(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("readfile", ...args);
}

/**
 * **{func}** is called for every item in **{object}**, which can be a
 * `String`, `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:
 *
 *     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 })
 *     echo reduce('xyz', { acc, val -> acc .. ',' .. val })
 *
 * Can also be used as a `method`:
 *
 *     echo mylist->reduce({ acc, val -> acc + val }, 0)
 */
export function reduce(
  denops: Denops,
  object: unknown,
  func: unknown,
  initial?: unknown,
): Promise<unknown>;
export function reduce(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("reduce", ...args);
}

/**
 * Returns the single letter name of the register being executed.
 * Returns an empty string when no register is being executed.
 * See `@`.
 */
export function reg_executing(denops: Denops): Promise<unknown>;
export function reg_executing(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("reg_executing", ...args);
}

/**
 * Returns the single letter name of the register being recorded.
 * Returns an empty string when not recording.  See `q`.
 */
export function reg_recording(denops: Denops): Promise<unknown>;
export function reg_recording(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("reg_recording", ...args);
}

/**
 * Return an item that represents a time value.  The item is a
 * list with items that depend on the system.  In Vim 9 script
 * list<any> can be used.
 * The item can be passed to `reltimestr()` to convert it to a
 * string or `reltimefloat()` to convert to a Float.
 *
 * Without an argument reltime() returns the current time (the
 * representation is system-dependent, it can not be used as the
 * wall-clock time, see `localtime()` for that).
 * With one argument is 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().  If there is an error an empty List is returned in
 * legacy script, in Vim9 script an error is given.
 *
 * Can also be used as a `method`:
 *
 *     GetStart()->reltime()
 *
 * *only available when compiled with the `+reltime` feature*
 */
export function reltime(
  denops: Denops,
  start?: unknown,
  end?: unknown,
): Promise<unknown>;
export function reltime(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("reltime", ...args);
}

/**
 * Return a Float that represents the time value of **{time}**.
 * 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 0.0 is returned in legacy script, in Vim9
 * script an error is given.
 *
 * Can also be used as a `method`:
 *
 *     reltime(start)->reltimefloat()
 *
 * *only available when compiled with the `+reltime` feature*
 */
export function reltimefloat(denops: Denops, time: unknown): Promise<unknown>;
export function reltimefloat(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("reltimefloat", ...args);
}

/**
 * Return a String that represents the time value of **{time}**.
 * This is the number of seconds, a dot and the number of
 * microseconds.  Example:
 *
 *     let start = reltime()
 *     call MyFunction()
 *     echo reltimestr(reltime(start))
 *
 * Note that overhead for the commands will be added to the time.
 * The accuracy depends on the system.
 * Leading spaces are used to make the string align nicely.  You
 * can use split() to remove it.
 *
 *     echo split(reltimestr(reltime(start)))[0]
 *
 * Also see `profiling`.
 * If there is an error an empty string is returned in legacy
 * script, in Vim9 script an error is given.
 *
 * Can also be used as a `method`:
 *
 *     reltime(start)->reltimestr()
 *
 * *only available when compiled with the `+reltime` feature*
 */
export function reltimestr(denops: Denops, time: unknown): Promise<unknown>;
export function reltimestr(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("reltimestr", ...args);
}

/**
 * Without **{end}**: Remove the item at **{idx}** from `List` **{list}** and
 * return the item.
 * With **{end}**: Remove items from **{idx}** to **{end}** (inclusive) and
 * return a `List` with these items.  When **{idx}** points to the same
 * item as **{end}** a list with one item is returned.  When **{end}**
 * points to an item before **{idx}** this is an error.
 * See `list-index` for possible values of **{idx}** and **{end}**.
 * Returns zero on error.
 * Example:
 *
 *     :echo "last item: " .. remove(mylist, -1)
 *     :call remove(mylist, 0, 9)
 *
 * Use `delete()` to remove a file.
 *
 * Can also be used as a `method`:
 *
 *     mylist->remove(idx)
 */
export function remove(
  denops: Denops,
  list: unknown,
  idx: unknown,
  end?: unknown,
): Promise<unknown>;
export function remove(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("remove", ...args);
}

/**
 * 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`:
 *
 *     GetOldName()->rename(newname)
 */
export function rename(
  denops: Denops,
  from: unknown,
  to: unknown,
): Promise<unknown>;
export function rename(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("rename", ...args);
}

/**
 * Repeat **{expr}** **{count}** times and return the concatenated
 * result.  Example:
 *
 *     :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:
 *
 *     :let longlist = repeat(['a', 'b'], 3)
 *
 * Results in ['a', 'b', 'a', 'b', 'a', 'b'].
 *
 * Can also be used as a `method`:
 *
 *     mylist->repeat(count)
 */
export function repeat(
  denops: Denops,
  expr: unknown,
  count: unknown,
): Promise<unknown>;
export function repeat(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("repeat", ...args);
}

/**
 * On MS-Windows, when **{filename}** is a shortcut (a .lnk file),
 * returns the path the shortcut points to in a simplified form.
 * When **{filename}** is a symbolic link or junction point, return
 * the full path to the target. If the target of junction is
 * removed, return **{filename}**.
 * 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`:
 *
 *     GetName()->resolve()
 */
export function resolve(denops: Denops, filename: unknown): Promise<unknown>;
export function resolve(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("resolve", ...args);
}

/**
 * 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:
 *
 *     :let revlist = reverse(copy(mylist))
 *
 * Can also be used as a `method`:
 *
 *     mylist->reverse()
 */
export function reverse(denops: Denops, object: unknown): Promise<unknown>;
export function reverse(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("reverse", ...args);
}

/**
 * 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:
 *
 *     echo round(0.456)
 *
 *         0.0
 *
 *     echo round(4.5)
 *
 *         5.0
 *
 *     echo round(-4.5)
 *
 *         -5.0
 *
 * Can also be used as a `method`:
 *
 *     Compute()->round()
 *
 * *only available when compiled with the `+float` feature*
 */
export function round(denops: Denops, expr: unknown): Promise<unknown>;
export function round(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("round", ...args);
}

/**
 * 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.
 * Note that in a `:def` function local variables are not visible
 * to **{expr}**.
 *
 * Can also be used as a `method`:
 *
 *     GetRubyExpr()->rubyeval()
 *
 * *only available when compiled with the `+ruby` feature*
 */
export function rubyeval(denops: Denops, expr: unknown): Promise<unknown>;
export function rubyeval(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("rubyeval", ...args);
}

/**
 * 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`:
 *
 *     GetRow()->screenattr(col)
 */
export function screenattr(
  denops: Denops,
  row: unknown,
  col: unknown,
): Promise<unknown>;
export function screenattr(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("screenattr", ...args);
}

/**
 * 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`:
 *
 *     GetRow()->screenchar(col)
 */
export function screenchar(
  denops: Denops,
  row: unknown,
  col: unknown,
): Promise<unknown>;
export function screenchar(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("screenchar", ...args);
}

/**
 * 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`:
 *
 *     GetRow()->screenchars(col)
 */
export function screenchars(
  denops: Denops,
  row: unknown,
  col: unknown,
): Promise<unknown>;
export function screenchars(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("screenchars", ...args);
}

/**
 * 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:
 *
 *     nnoremap <expr> GG ":echom " .. screencol() .. "\n"
 *     nnoremap <silent> GG :echom screencol()<CR>
 *     nnoremap GG <Cmd>echom screencol()<CR>
 */
export function screencol(denops: Denops): Promise<unknown>;
export function screencol(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("screencol", ...args);
}

/**
 * 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()`.
 */
export function screenrow(denops: Denops): Promise<unknown>;
export function screenrow(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("screenrow", ...args);
}

/**
 * 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`:
 *
 *     GetRow()->screenstring(col)
 */
export function screenstring(
  denops: Denops,
  row: unknown,
  col: unknown,
): Promise<unknown>;
export function screenstring(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("screenstring", ...args);
}

/**
 * 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:
 *
 *     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.
 * *only available when compiled with the `+reltime` feature*
 *
 * 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):
 *
 *     :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:
 *
 *     :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`:
 *
 *     GetPattern()->search()
 */
export function search(
  denops: Denops,
  pattern: unknown,
  flags?: unknown,
  stopline?: unknown,
  timeout?: unknown,
  skip?: unknown,
): Promise<unknown>;
export function search(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("search", ...args);
}

/**
 * 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`:
 *
 *     " 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':
 *
 *     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:
 *
 *     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":
 *
 *     " 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
 *
 *                                     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: 99)
 *   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`:
 *
 *     GetSearchOpts()->searchcount()
 */
export function searchcount(
  denops: Denops,
  options?: unknown,
): Promise<unknown>;
export function searchcount(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("searchcount", ...args);
}

/**
 * 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:
 *
 *     if searchdecl('myvar') == 0
 *        echo getline('.')
 *     endif
 *
 * Can also be used as a `method`:
 *
 *     GetName()->searchdecl()
 */
export function searchdecl(
  denops: Denops,
  name: unknown,
  global?: unknown,
  thisblock?: unknown,
): Promise<unknown>;
export function searchdecl(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("searchdecl", ...args);
}

/**
 * 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:
 *
 *     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.
 * In a `:def` function when the **{skip}** argument is a string
 * constant it is compiled into instructions.
 *
 * 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:
 *
 *     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:
 *
 *     :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 a line is considered a
 * match.
 * Another example, to search for the matching "{" of a "}":
 *
 *     :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:
 *
 *     :echo searchpair('{', '', '}', 'bW',
 *          \ 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string"')
 */
export function searchpair(
  denops: Denops,
  start: unknown,
  middle: unknown,
  end: unknown,
  flags?: unknown,
  skip?: unknown,
  stopline?: unknown,
  timeout?: unknown,
): Promise<unknown>;
export function searchpair(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("searchpair", ...args);
}

/**
 * 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].
 *
 *     :let [lnum,col] = searchpairpos('{', '', '}', 'n')
 *
 * See `match-parens` for a bigger and more useful example.
 */
export function searchpairpos(
  denops: Denops,
  start: unknown,
  middle: unknown,
  end: unknown,
  flags?: unknown,
  skip?: unknown,
  stopline?: unknown,
  timeout?: unknown,
): Promise<unknown>;
export function searchpairpos(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("searchpairpos", ...args);
}

/**
 * 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:
 *
 *     :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:
 *
 *     :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`:
 *
 *     GetPattern()->searchpos()
 */
export function searchpos(
  denops: Denops,
  pattern: unknown,
  flags?: unknown,
  stopline?: unknown,
  timeout?: unknown,
  skip?: unknown,
): Promise<unknown>;
export function searchpos(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("searchpos", ...args);
}

/**
 * Return a list of available server names, one per line.
 * When there are no servers or the information is not available
 * an empty string is returned.  See also `clientserver`.
 * *only available when compiled with the `+clientserver` feature*
 * Example:
 *
 *     :echo serverlist()
 */
export function serverlist(denops: Denops): Promise<unknown>;
export function serverlist(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("serverlist", ...args);
}

/**
 * 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:
 *
 *     :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:
 *
 *     GetValue()->setbufvar(buf, varname)
 */
export function setbufvar(
  denops: Denops,
  buf: unknown,
  varname: unknown,
  val: unknown,
): Promise<unknown>;
export function setbufvar(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("setbufvar", ...args);
}

/**
 * Specify overrides for cell widths of character ranges.  This
 * tells Vim how wide characters are, counted in screen cells.
 * This overrides 'ambiwidth'.  Example:
 *
 *     setcellwidths([[0xad, 0xad, 1],
 *                  \ [0x2194, 0x2199, 2]])
 *
 * The **{list}** argument is a list of lists with each three
 * numbers. These three numbers are [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).  "width" is 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.
 * Only characters with value 0x100 and higher can be used.
 *
 * 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:
 *
 *     setcellwidths([]);
 *
 * You can use the script $VIMRUNTIME/tools/emoji_list.vim to see
 * the effect for known emoji characters.
 */
export function setcellwidths(denops: Denops, list: unknown): Promise<unknown>;
export function setcellwidths(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("setcellwidths", ...args);
}

/**
 * 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:
 *
 *     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`:
 *
 *     GetPosition()->setcharpos('.')
 */
export function setcharpos(
  denops: Denops,
  expr: unknown,
  list: unknown,
): Promise<unknown>;
export function setcharpos(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("setcharpos", ...args);
}

/**
 * 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:
 *
 *     :let prevsearch = getcharsearch()
 *     :" Perform a command which clobbers user's search
 *     :call setcharsearch(prevsearch)
 *
 * Also see `getcharsearch()`.
 *
 * Can also be used as a `method`:
 *
 *     SavedSearch()->setcharsearch()
 */
export function setcharsearch(denops: Denops, dict: unknown): Promise<unknown>;
export function setcharsearch(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("setcharsearch", ...args);
}

/**
 * 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`:
 *
 *     GetText()->setcmdline()
 */
export function setcmdline(
  denops: Denops,
  str: unknown,
  pos?: unknown,
): Promise<unknown>;
export function setcmdline(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("setcmdline", ...args);
}

/**
 * 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`:
 *
 *     GetPos()->setcmdpos()
 */
export function setcmdpos(denops: Denops, pos: unknown): Promise<unknown>;
export function setcmdpos(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("setcmdpos", ...args);
}

/**
 * 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:
 *
 *     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`:
 *
 *     GetCursorPos()->setcursorcharpos()
 */
export function setcursorcharpos(
  denops: Denops,
  lnum: unknown,
  col: unknown,
  off?: unknown,
): Promise<unknown>;
export function setcursorcharpos(
  denops: Denops,
  list: unknown,
): Promise<unknown>;
export function setcursorcharpos(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("setcursorcharpos", ...args);
}

/**
 * Set environment variable **{name}** to **{val}**.  Example:
 *
 *     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:
 *
 *     GetPath()->setenv('PATH')
 */
export function setenv(
  denops: Denops,
  name: unknown,
  val: unknown,
): Promise<unknown>;
export function setenv(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("setenv", ...args);
}

/**
 * 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`:
 *
 *     GetFilename()->setfperm(mode)
 *
 * To read permissions see `getfperm()`.
 */
export function setfperm(
  denops: Denops,
  fname: unknown,
  mode: unknown,
): Promise<unknown>;
export function setfperm(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("setfperm", ...args);
}

/**
 * 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:
 *
 *     GetLoclist()->setloclist(winnr)
 */
export function setloclist(
  denops: Denops,
  nr: unknown,
  list: unknown,
  action?: unknown,
  what?: unknown,
): Promise<unknown>;
export function setloclist(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("setloclist", ...args);
}

/**
 * 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`:
 *
 *     GetMatches()->setmatches()
 */
export function setmatches(
  denops: Denops,
  list: unknown,
  win?: unknown,
): Promise<unknown>;
export function setmatches(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("setmatches", ...args);
}

/**
 * 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:
 *
 *             :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`):
 *
 *     :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:
 *
 *     GetErrorlist()->setqflist()
 */
export function setqflist(
  denops: Denops,
  list: unknown,
  action?: unknown,
  what?: unknown,
): Promise<unknown>;
export function setqflist(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("setqflist", ...args);
}

/**
 * Set the register **{regname}** to **{value}**.
 * If **{regname}** is "" or "@", the unnamed register '"' is used.
 * The **{regname}** argument is a string.  In `Vim9-script`
 * **{regname}** must be one character.
 *
 * **{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"        `characterwise` 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 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:
 *
 *     :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:
 *
 *     :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:
 *
 *     :call setreg('a', '', 'al')
 *
 * Can also be used as a `method`, the base is passed as the
 * second argument:
 *
 *     GetText()->setreg('a')
 */
export function setreg(
  denops: Denops,
  regname: unknown,
  value: unknown,
  options?: unknown,
): Promise<unknown>;
export function setreg(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("setreg", ...args);
}

/**
 * Set tab-local variable **{varname}** to **{val}** in tab page **{tabnr}**.
 * `t:var`
 * The **{varname}** argument is a string.
 * Note that autocommands are blocked, side effects may not be
 * triggered, e.g. when setting 'filetype'.
 * 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:
 *
 *     GetValue()->settabvar(tab, name)
 */
export function settabvar(
  denops: Denops,
  tabnr: unknown,
  varname: unknown,
  val: unknown,
): Promise<unknown>;
export function settabvar(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("settabvar", ...args);
}

/**
 * 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.
 * Note that autocommands are blocked, side effects may not be
 * triggered, e.g. when setting 'filetype' or 'syntax'.
 * 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:
 *
 *     :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:
 *
 *     GetValue()->settabwinvar(tab, winnr, name)
 */
export function settabwinvar(
  denops: Denops,
  tabnr: unknown,
  winnr: unknown,
  varname: unknown,
  val: unknown,
): Promise<unknown>;
export function settabwinvar(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("settabwinvar", ...args);
}

/**
 * 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:
 *
 *         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:
 *
 *     GetStack()->settagstack(winnr)
 */
export function settagstack(
  denops: Denops,
  nr: unknown,
  dict: unknown,
  action?: unknown,
): Promise<unknown>;
export function settagstack(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("settagstack", ...args);
}

/**
 * Like `settabwinvar()` for the current tab page.
 * Examples:
 *
 *     :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:
 *
 *     GetValue()->setwinvar(winnr, name)
 */
export function setwinvar(
  denops: Denops,
  winnr: unknown,
  varname: unknown,
  val: unknown,
): Promise<unknown>;
export function setwinvar(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("setwinvar", ...args);
}

/**
 * Returns a String with 64 hex characters, which is the SHA256
 * checksum of **{string}**.
 *
 * Can also be used as a `method`:
 *
 *     GetText()->sha256()
 *
 * *only available when compiled with the `+cryptv` feature*
 */
export function sha256(denops: Denops, string: unknown): Promise<unknown>;
export function sha256(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("sha256", ...args);
}

/**
 * Escape **{string}** for use as a shell command argument.
 * When the 'shell' contains powershell (MS-Windows) or pwsh
 * (MS-Windows, Linux, and macOS) then it will enclose **{string}**
 * in single quotes and will double up all internal single
 * quotes.
 * On MS-Windows, when 'shellslash' is not set, it will enclose
 * **{string}** in double quotes and double all double quotes within
 * **{string}**.
 * Otherwise it will enclose **{string}** in single quotes and
 * replace all "'" with "'\''".
 *
 * When the **{special}** argument is present and it's a non-zero
 * Number or a non-empty String (`non-zero-arg`), then special
 * items such as "!", "%", "#" and `"<cword>"` will be preceded by
 * a backslash.  This backslash will be removed again by the `:!`
 * command.
 *
 * The "!" character will be escaped (again with a `non-zero-arg`
 * **{special}**) when 'shell' contains "csh" in the tail.  That is
 * because for csh and tcsh "!" is used for history replacement
 * even when inside single quotes.
 *
 * With a `non-zero-arg` **{special}** the `<NL>` character is also
 * escaped.  When 'shell' containing "csh" in the tail it's
 * escaped a second time.
 *
 * The "\" character will be escaped when 'shell' contains "fish"
 * in the tail. That is because for fish "\" is used as an escape
 * character inside single quotes.
 *
 * Example of use with a `:!` command:
 *
 *     :exe '!dir ' .. shellescape(expand('<cfile>'), 1)
 *
 * This results in a directory listing for the file under the
 * cursor.  Example of use with `system()`:
 *
 *     :call system("chmod +w -- " .. shellescape(expand("%")))
 *
 * See also `::S`.
 *
 * Can also be used as a `method`:
 *
 *     GetCommand()->shellescape()
 */
export function shellescape(
  denops: Denops,
  string: unknown,
  special?: unknown,
): Promise<unknown>;
export function shellescape(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("shellescape", ...args);
}

/**
 * Returns the effective value of 'shiftwidth'. This is the
 * 'shiftwidth' value unless it is zero, in which case it is the
 * 'tabstop' value.  This function was introduced with patch
 * 7.3.694 in 2012, everybody should have it by now (however it
 * did not allow for the optional **{col}** argument until 8.1.542).
 *
 * 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 the 'vartabstop' setting is enabled and
 * no **{col}** argument is given, column 1 will be assumed.
 *
 * Can also be used as a `method`:
 *
 *     GetColumn()->shiftwidth()
 */
export function shiftwidth(denops: Denops, col?: unknown): Promise<unknown>;
export function shiftwidth(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("shiftwidth", ...args);
}

/**
 * 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:
 *
 *     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`:
 *
 *     GetName()->simplify()
 */
export function simplify(denops: Denops, filename: unknown): Promise<unknown>;
export function simplify(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("simplify", ...args);
}

/**
 * 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:
 *
 *     :echo sin(100)
 *
 *         -0.506366
 *
 *     :echo sin(-4.01)
 *
 *         0.763301
 *
 * Can also be used as a `method`:
 *
 *     Compute()->sin()
 *
 * *only available when compiled with the `+float` feature*
 */
export function sin(denops: Denops, expr: unknown): Promise<unknown>;
export function sin(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("sin", ...args);
}

/**
 * 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:
 *
 *     :echo sinh(0.5)
 *
 *         0.521095
 *
 *     :echo sinh(-0.9)
 *
 *         -1.026517
 *
 * Can also be used as a `method`:
 *
 *     Compute()->sinh()
 *
 * *only available when compiled with the `+float` feature*
 */
export function sinh(denops: Denops, expr: unknown): Promise<unknown>;
export function sinh(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("sinh", ...args);
}

/**
 * Sort the items in **{list}** in-place.  Returns **{list}**.
 *
 * If you want a list to remain unmodified make a copy first:
 *
 *     :let sortedlist = sort(copy(mylist))
 *
 * When **{how}** is omitted or is a string, 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 **{how}** is given and it is 'i' then case is ignored.
 * In legacy script, for backwards compatibility, the value one
 * can be used to ignore case.  Zero means to not ignore case.
 *
 * When **{how}** 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:
 *
 *     " ö 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']
 *
 *     " ö 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 **{how}** 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 **{how}** 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 **{how}** is given and it is 'f' then all items will be
 * sorted numerical. All values must be a Number or a Float.
 *
 * When **{how}** 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`:
 *
 *     mylist->sort()
 *
 * Also see `uniq()`.
 *
 * Example:
 *
 *     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:
 *
 *     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})
 */
export function sort(
  denops: Denops,
  list: unknown,
  how?: unknown,
  dict?: unknown,
): Promise<unknown>;
export function sort(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("sort", ...args);
}

/**
 * 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`:
 *
 *     GetWord()->soundfold()
 */
export function soundfold(denops: Denops, word: unknown): Promise<unknown>;
export function soundfold(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("soundfold", ...args);
}

/**
 * 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:
 *
 *     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`:
 *
 *     GetText()->spellbadword()
 */
export function spellbadword(
  denops: Denops,
  sentence?: unknown,
): Promise<unknown>;
export function spellbadword(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("spellbadword", ...args);
}

/**
 * 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`:
 *
 *     GetWord()->spellsuggest()
 */
export function spellsuggest(
  denops: Denops,
  word: unknown,
  max?: unknown,
  capital?: unknown,
): Promise<unknown>;
export function spellsuggest(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("spellsuggest", ...args);
}

/**
 * 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:
 *
 *     :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:
 *
 *     :echo split('abc:def:ghi', ':\zs')
 *
 *         ['abc:', 'def:', 'ghi']
 * Splitting a table where the first element can be empty:
 *
 *     :let items = split(line, ':', 1)
 *
 * The opposite function is `join()`.
 *
 * Can also be used as a `method`:
 *
 *     GetString()->split()
 */
export function split(
  denops: Denops,
  string: unknown,
  pattern?: unknown,
  keepempty?: unknown,
): Promise<unknown>;
export function split(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("split", ...args);
}

/**
 * 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:
 *
 *     :echo sqrt(100)
 *
 *         10.0
 *
 *     :echo sqrt(-4.01)
 *
 *         nan
 * "nan" may be different, it depends on system libraries.
 *
 * Can also be used as a `method`:
 *
 *     Compute()->sqrt()
 *
 * *only available when compiled with the `+float` feature*
 */
export function sqrt(denops: Denops, expr: unknown): Promise<unknown>;
export function sqrt(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("sqrt", ...args);
}

/**
 * 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:
 *
 *     :let seed = srand()
 *     :let seed = srand(userinput)
 *     :echo rand(seed)
 */
export function srand(denops: Denops, expr?: unknown): Promise<unknown>;
export function srand(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("srand", ...args);
}

/**
 * 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()`:
 *
 *     let f = str2float(substitute(text, ',', '', 'g'))
 *
 * Returns 0.0 if the conversion fails.
 *
 * Can also be used as a `method`:
 *
 *     let f = text->substitute(',', '', 'g')->str2float()
 *
 * *only available when compiled with the `+float` feature*
 */
export function str2float(
  denops: Denops,
  string: unknown,
  quoted?: unknown,
): Promise<unknown>;
export function str2float(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("str2float", ...args);
}

/**
 * Return a list containing the number values which represent
 * each character in String **{string}**.  Examples:
 *
 *     str2list(" ")           returns [32]
 *     str2list("ABC")         returns [65, 66, 67]
 *
 * `list2str()` does the opposite.
 *
 * When **{utf8}** is omitted or zero, the current 'encoding' is used.
 * When **{utf8}** is TRUE, always treat the String as UTF-8
 * characters.  With UTF-8 composing characters are handled
 * properly:
 *
 *     str2list("á")          returns [97, 769]
 *
 * Can also be used as a `method`:
 *
 *     GetString()->str2list()
 */
export function str2list(
  denops: Denops,
  string: unknown,
  utf8?: unknown,
): Promise<unknown>;
export function str2list(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("str2list", ...args);
}

/**
 * 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:
 *
 *     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`:
 *
 *     GetText()->str2nr()
 */
export function str2nr(
  denops: Denops,
  string: unknown,
  base?: unknown,
  quoted?: unknown,
): Promise<unknown>;
export function str2nr(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("str2nr", ...args);
}

/**
 * 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:
 *
 *     strcharpart('abc', -1, 2)
 *
 * results in 'a'.
 *
 * Returns an empty string on error.
 *
 * Can also be used as a `method`:
 *
 *     GetText()->strcharpart(5)
 */
export function strcharpart(
  denops: Denops,
  src: unknown,
  start: unknown,
  len?: unknown,
  skipcc?: unknown,
): Promise<unknown>;
export function strcharpart(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("strcharpart", ...args);
}

/**
 * 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:
 *
 *     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`:
 *
 *     GetText()->strchars()
 */
export function strchars(
  denops: Denops,
  string: unknown,
  skipcc?: unknown,
): Promise<unknown>;
export function strchars(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("strchars", ...args);
}

/**
 * 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`:
 *
 *     GetText()->strdisplaywidth()
 */
export function strdisplaywidth(
  denops: Denops,
  string: unknown,
  col?: unknown,
): Promise<unknown>;
export function strdisplaywidth(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("strdisplaywidth", ...args);
}

/**
 * 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:
 *
 *     :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.
 *
 * Not available on all systems.  To check use:
 *
 *     :if exists("*strftime")
 *
 * Can also be used as a `method`:
 *
 *     GetFormat()->strftime()
 */
export function strftime(
  denops: Denops,
  format: unknown,
  time?: unknown,
): Promise<unknown>;
export function strftime(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("strftime", ...args);
}

/**
 * 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`:
 *
 *     GetText()->strgetchar(5)
 */
export function strgetchar(
  denops: Denops,
  str: unknown,
  index: unknown,
): Promise<unknown>;
export function strgetchar(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("strgetchar", ...args);
}

/**
 * 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:
 *
 *     :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:
 *
 *     :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`:
 *
 *     GetHaystack()->stridx(needle)
 */
export function stridx(
  denops: Denops,
  haystack: unknown,
  needle: unknown,
  start?: unknown,
): Promise<unknown>;
export function stridx(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("stridx", ...args);
}

/**
 * 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' (single quotes are doubled)
 *         Number          123
 *         Float           123.123456 or 1.123456e8
 *         Funcref         function('name')
 *         Blob            0z00112233.44556677.8899
 *         List            [item, item]
 *         Dictionary      {key: value, key: value}
 *
 * When a `List` or `Dictionary` has a recursive reference it is
 * replaced by "[...]" or "**{...}**".  Using eval() on the result
 * will then fail.
 *
 * Can also be used as a `method`:
 *
 *     mylist->string()
 *
 * Also see `strtrans()`.
 */
export function string(denops: Denops, expr: unknown): Promise<unknown>;
export function string(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("string", ...args);
}

/**
 * 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`:
 *
 *     GetString()->strlen()
 */
export function strlen(denops: Denops, string: unknown): Promise<unknown>;
export function strlen(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("strlen", ...args);
}

/**
 * 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}**.
 *
 *     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:
 *
 *     strpart(getline("."), col(".") - 1, 1, v:true)
 *
 * Returns an empty string on error.
 *
 * Can also be used as a `method`:
 *
 *     GetText()->strpart(5)
 */
export function strpart(
  denops: Denops,
  src: unknown,
  start: unknown,
  len?: unknown,
  chars?: unknown,
): Promise<unknown>;
export function strpart(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("strpart", ...args);
}

/**
 * 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:
 *
 *     :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
 *
 *     :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`:
 *
 *     GetFormat()->strptime(timestring)
 *
 * Not available on all systems.  To check use:
 *
 *     :if exists("*strptime")
 */
export function strptime(
  denops: Denops,
  format: unknown,
  timestring: unknown,
): Promise<unknown>;
export function strptime(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("strptime", ...args);
}

/**
 * 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:
 *
 *     :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:
 *
 *     :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`:
 *
 *     GetHaystack()->strridx(needle)
 */
export function strridx(
  denops: Denops,
  haystack: unknown,
  needle: unknown,
  start?: unknown,
): Promise<unknown>;
export function strridx(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("strridx", ...args);
}

/**
 * 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:
 *
 *     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`:
 *
 *     GetString()->strtrans()
 */
export function strtrans(denops: Denops, string: unknown): Promise<unknown>;
export function strtrans(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("strtrans", ...args);
}

/**
 * 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`:
 *
 *     GetString()->strwidth()
 */
export function strwidth(denops: Denops, string: unknown): Promise<unknown>;
export function strwidth(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("strwidth", ...args);
}

/**
 * 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:
 *
 *     :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`:
 *
 *     GetNr()->submatch()
 */
export function submatch(
  denops: Denops,
  nr: unknown,
  list?: unknown,
): Promise<unknown>;
export function submatch(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("submatch", ...args);
}

/**
 * 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:
 *
 *     :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:
 *
 *     :echo substitute(s, '%\(\x\x\)',
 *             \ '\=nr2char("0x" .. submatch(1))', 'g')
 *
 * When **{sub}** is a Funcref that function is called, with one
 * optional argument.  Example:
 *
 *     :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:
 *
 *     :echo substitute(s, '%\(\x\x\)', {m -> '0x' .. m[1]}, 'g')
 *
 * Returns an empty string on error.
 *
 * Can also be used as a `method`:
 *
 *     GetString()->substitute(pat, sub, flags)
 */
export function substitute(
  denops: Denops,
  string: unknown,
  pat: unknown,
  sub: unknown,
  flags: unknown,
): Promise<unknown>;
export function substitute(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("substitute", ...args);
}

/**
 * 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
 * Note that "user" and "host" are truncated to at most 39 bytes.
 * 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`:
 *
 *     GetFilename()->swapinfo()
 */
export function swapinfo(denops: Denops, fname: unknown): Promise<unknown>;
export function swapinfo(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("swapinfo", ...args);
}

/**
 * The result is the swap file path of the buffer **{expr}**.
 * 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`:
 *
 *     GetBufname()->swapname()
 */
export function swapname(denops: Denops, buf: unknown): Promise<unknown>;
export function swapname(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("swapname", ...args);
}

/**
 * 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):
 *
 *     :echo synIDattr(synID(line("."), col("."), 1), "name")
 */
export function synID(
  denops: Denops,
  lnum: unknown,
  col: unknown,
  trans: unknown,
): Promise<unknown>;
export function synID(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("synID", ...args);
}

/**
 * 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", "cterm" or "term", 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, cterm or term).
 * 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 for the GUI (as with "fg")
 *                 `highlight-guisp`
 * "ul"            underline color for cterm: number as a string
 * "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
 * "strike"        "1" if strikethrough
 * "nocombine"     "1" if nocombine
 *
 * Returns an empty string on error.
 *
 * Example (echoes the color of the syntax item under the
 * cursor):
 *
 *     :echo synIDattr(synIDtrans(synID(line("."), col("."), 1)), "fg")
 *
 * Can also be used as a `method`:
 *
 *     :echo synID(line("."), col("."), 1)->synIDtrans()->synIDattr("fg")
 */
export function synIDattr(
  denops: Denops,
  synID: unknown,
  what: unknown,
  mode?: unknown,
): Promise<unknown>;
export function synIDattr(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("synIDattr", ...args);
}

/**
 * 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`:
 *
 *     :echo synID(line("."), col("."), 1)->synIDtrans()->synIDattr("fg")
 */
export function synIDtrans(denops: Denops, synID: unknown): Promise<unknown>;
export function synIDtrans(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("synIDtrans", ...args);
}

/**
 * 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]
 */
export function synconcealed(
  denops: Denops,
  lnum: unknown,
  col: unknown,
): Promise<unknown>;
export function synconcealed(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("synconcealed", ...args);
}

/**
 * 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:
 *
 *     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.
 */
export function synstack(
  denops: Denops,
  lnum: unknown,
  col: unknown,
): Promise<unknown>;
export function synstack(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("synstack", ...args);
}

/**
 * Get the output of the shell command **{expr}** as a `String`.  See
 * `systemlist()` to get the output as a `List`.
 *
 * When **{input}** is given and is a `String` this string is written
 * to a file and passed as stdin to the command.  The string is
 * written as-is, you need to take care of using the correct line
 * separators yourself.
 * If **{input}** is given and is a `List` it is written to the file
 * in a way `writefile()` does with **{binary}** set to "b" (i.e.
 * with a newline between each list item with newlines inside
 * list items converted to NULs).
 * When **{input}** is given and is a number that is a valid id for
 * an existing buffer then the content of the buffer is written
 * to the file line by line, each line terminated by a NL and
 * NULs characters where the text has a NL.
 *
 * Pipes are not used, the 'shelltemp' option is not used.
 *
 * When prepended by `:silent` the terminal will not be set to
 * cooked mode.  This is meant to be used for commands that do
 * not need the user to type.  It avoids stray characters showing
 * up on the screen which require `CTRL-L` to remove.
 *
 *     :silent let f = system('ls *.vim')
 *
 * Note: Use `shellescape()` or `::S` with `expand()` or
 * `fnamemodify()` to escape special characters in a command
 * argument.  Newlines in **{expr}** may cause the command to fail.
 * The characters in 'shellquote' and 'shellxquote' may also
 * cause trouble.
 * This is not to be used for interactive commands.
 *
 * The result is a String.  Example:
 *
 *     :let files = system('ls ' .. shellescape(expand('%:h')))
 *     :let files = system('ls ' .. expand('%:h:S'))
 *
 * To make the result more system-independent, the shell output
 * is filtered to replace `<CR>` with `<NL>` for Macintosh, and
 * `<CR><NL>` with `<NL>` for DOS-like systems.
 * To avoid the string being truncated at a NUL, all NUL
 * characters are replaced with SOH (0x01).
 *
 * The command executed is constructed using several options:
 *         'shell' 'shellcmdflag' 'shellxquote' **{expr}** 'shellredir' **{tmp}** 'shellxquote'
 * (**{tmp}** is an automatically generated file name).
 * For Unix, braces are put around **{expr}** to allow for
 * concatenated commands.
 *
 * The command will be executed in "cooked" mode, so that a
 * CTRL-C will interrupt the command (on Unix at least).
 *
 * The resulting error code can be found in `v:shell_error`.
 * This function will fail in `restricted-mode`.
 *
 * Note that any wrong value in the options mentioned above may
 * make the function fail.  It has also been reported to fail
 * when using a security agent application.
 * Unlike ":!cmd" there is no automatic check for changed files.
 * Use `:checktime` to force a check.
 *
 * Can also be used as a `method`:
 *
 *     :echo GetCmd()->system()
 */
export function system(
  denops: Denops,
  expr: unknown,
  input?: unknown,
): Promise<unknown>;
export function system(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("system", ...args);
}

/**
 * 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 there is no extra empty item when the
 * result ends in a NL.
 * 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()`:
 *
 *     echo system('echo hello')->split('\n', 1)
 *
 * Returns an empty string on error.
 *
 * Can also be used as a `method`:
 *
 *     :echo GetCmd()->systemlist()
 */
export function systemlist(
  denops: Denops,
  expr: unknown,
  input?: unknown,
): Promise<unknown>;
export function systemlist(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("systemlist", ...args);
}

/**
 * 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:
 *
 *     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`:
 *
 *     GetTabpage()->tabpagebuflist()
 */
export function tabpagebuflist(denops: Denops, arg?: unknown): Promise<unknown>;
export function tabpagebuflist(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("tabpagebuflist", ...args);
}

/**
 * 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.
 */
export function tabpagenr(denops: Denops, arg?: unknown): Promise<unknown>;
export function tabpagenr(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("tabpagenr", ...args);
}

/**
 * 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:
 *
 *     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`:
 *
 *     GetTabpage()->tabpagewinnr()
 */
export function tabpagewinnr(
  denops: Denops,
  tabarg: unknown,
  arg?: unknown,
): Promise<unknown>;
export function tabpagewinnr(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("tabpagewinnr", ...args);
}

/**
 * Returns a `List` with the file names used to search for tags
 * for the current buffer.  This is the 'tags' option expanded.
 */
export function tagfiles(denops: Denops): Promise<unknown>;
export function tagfiles(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("tagfiles", ...args);
}

/**
 * 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`:
 *
 *     GetTagpattern()->taglist()
 */
export function taglist(
  denops: Denops,
  expr: unknown,
  filename?: unknown,
): Promise<unknown>;
export function taglist(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("taglist", ...args);
}

/**
 * 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:
 *
 *     :echo tan(10)
 *
 *         0.648361
 *
 *     :echo tan(-4.01)
 *
 *         -1.181502
 *
 * Can also be used as a `method`:
 *
 *     Compute()->tan()
 *
 * *only available when compiled with the `+float` feature*
 */
export function tan(denops: Denops, expr: unknown): Promise<unknown>;
export function tan(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("tan", ...args);
}

/**
 * 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:
 *
 *     :echo tanh(0.5)
 *
 *         0.462117
 *
 *     :echo tanh(-1)
 *
 *         -0.761594
 *
 * Can also be used as a `method`:
 *
 *     Compute()->tanh()
 *
 * *only available when compiled with the `+float` feature*
 */
export function tanh(denops: Denops, expr: unknown): Promise<unknown>;
export function tanh(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("tanh", ...args);
}

/**
 * The result is a String, which is the name of a file that
 * doesn't exist.  It can be used for a temporary file.  The name
 * is different for at least 26 consecutive calls.  Example:
 *
 *     :let tmpfile = tempname()
 *     :exe "redir > " .. tmpfile
 *
 * For Unix, the file will be in a private directory `tempfile`.
 * For MS-Windows forward slashes are used when the 'shellslash'
 * option is set, or when 'shellcmdflag' starts with '-' and
 * 'shell' does not contain powershell or pwsh.
 */
export function tempname(denops: Denops): Promise<unknown>;
export function tempname(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("tempname", ...args);
}

/**
 * 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
 *     "remaining"     time until the timer fires
 *     "repeat"        number of times the timer will still fire;
 *                     -1 means forever
 *     "callback"      the callback
 *     "paused"        1 if the timer is paused, 0 otherwise
 *
 * Can also be used as a `method`:
 *
 *     GetTimer()->timer_info()
 *
 * *only available when compiled with the `+timers` feature*
 */
export function timer_info(denops: Denops, id?: unknown): Promise<unknown>;
export function timer_info(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("timer_info", ...args);
}

/**
 * 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`:
 *
 *     GetTimer()->timer_pause(1)
 *
 * *only available when compiled with the `+timers` feature*
 */
export function timer_pause(
  denops: Denops,
  timer: unknown,
  paused: unknown,
): Promise<unknown>;
export function timer_pause(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("timer_pause", ...args);
}

/**
 * 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.
 *
 * **{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.
 * If you want to show a message look at `popup_notification()`
 * to avoid interfering with what the user is doing.
 *
 * **{options}** is a dictionary.  Supported entries:
 *    "repeat"     Number of times to repeat calling the
 *                 callback.  -1 means forever.  When not present
 *                 the callback will be called once.
 *                 If the timer causes an error three times in a
 *                 row the repeat is cancelled.  This avoids that
 *                 Vim becomes unusable because of all the error
 *                 messages.
 *
 * Returns -1 on error.
 *
 * Example:
 *
 *     func MyHandler(timer)
 *       echo 'Handler called'
 *     endfunc
 *     let timer = timer_start(500, 'MyHandler',
 *             \ {'repeat': 3})
 *
 * This will invoke MyHandler() three times at 500 msec
 * intervals.
 *
 * Can also be used as a `method`:
 *
 *     GetMsec()->timer_start(callback)
 *
 * Not available in the `sandbox`.
 * *only available when compiled with the `+timers` feature*
 */
export function timer_start(
  denops: Denops,
  time: unknown,
  callback: unknown,
  options?: unknown,
): Promise<unknown>;
export function timer_start(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("timer_start", ...args);
}

/**
 * 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`:
 *
 *     GetTimer()->timer_stop()
 *
 * *only available when compiled with the `+timers` feature*
 */
export function timer_stop(denops: Denops, timer: unknown): Promise<unknown>;
export function timer_stop(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("timer_stop", ...args);
}

/**
 * Stop all timers.  The timer callbacks will no longer be
 * invoked.  Useful if a timer is misbehaving.  If there are no
 * timers there is no error.
 *
 * *only available when compiled with the `+timers` feature*
 */
export function timer_stopall(denops: Denops): Promise<unknown>;
export function timer_stopall(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("timer_stopall", ...args);
}

/**
 * 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`:
 *
 *     GetText()->tolower()
 */
export function tolower(denops: Denops, expr: unknown): Promise<unknown>;
export function tolower(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("tolower", ...args);
}

/**
 * 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`:
 *
 *     GetText()->toupper()
 */
export function toupper(denops: Denops, expr: unknown): Promise<unknown>;
export function toupper(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("toupper", ...args);
}

/**
 * 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:
 *
 *     echo tr("hello there", "ht", "HT")
 *
 * returns "Hello THere"
 *
 *     echo tr("<blob>", "<>", "{}")
 *
 * returns "**{blob}**"
 *
 * Can also be used as a `method`:
 *
 *     GetText()->tr(from, to)
 */
export function tr(
  denops: Denops,
  src: unknown,
  fromstr: unknown,
  tostr: unknown,
): Promise<unknown>;
export function tr(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("tr", ...args);
}

/**
 * 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:
 *
 *     echo trim("   some text ")
 *
 * returns "some text"
 *
 *     echo trim("  \r\t\t\r RESERVE \t\n\x0B\xA0") .. "_TAIL"
 *
 * returns "RESERVE_TAIL"
 *
 *     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`:
 *
 *     GetText()->trim()
 */
export function trim(
  denops: Denops,
  text: unknown,
  mask?: unknown,
  dir?: unknown,
): Promise<unknown>;
export function trim(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("trim", ...args);
}

/**
 * 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:
 *
 *     echo trunc(1.456)
 *
 *         1.0
 *
 *     echo trunc(-5.456)
 *
 *         -5.0
 *
 *     echo trunc(4.0)
 *
 *         4.0
 *
 * Can also be used as a `method`:
 *
 *     Compute()->trunc()
 *
 * *only available when compiled with the `+float` feature*
 */
export function trunc(denops: Denops, expr: unknown): Promise<unknown>;
export function trunc(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("trunc", ...args);
}

/**
 * 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:t_bool` (v:false and v:true)
 *         None:       7  `v:t_none` (v:null and v:none)
 *         Job:        8  `v:t_job`
 *         Channel:    9  `v:t_channel`
 *         Blob:      10  `v:t_blob`
 * For backward compatibility, this method can be used:
 *
 *     :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:false)
 *     :if type(myvar) == type(v:none)
 *
 * To check if the v:t_ variables exist use this:
 *
 *     :if exists('v:t_number')
 *
 * Can also be used as a `method`:
 *
 *     mylist->type()
 */
export function type(denops: Denops, expr: unknown): Promise<unknown>;
export function type(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("type", ...args);
}

/**
 * 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`.
 * When compiled without the `+persistent_undo` option this always
 * returns an empty string.
 *
 * Can also be used as a `method`:
 *
 *     GetFilename()->undofile()
 */
export function undofile(denops: Denops, name: unknown): Promise<unknown>;
export function undofile(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("undofile", ...args);
}

/**
 * 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.
 */
export function undotree(denops: Denops): Promise<unknown>;
export function undotree(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("undotree", ...args);
}

/**
 * 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:
 *
 *     :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`:
 *
 *     mylist->uniq()
 */
export function uniq(
  denops: Denops,
  list: unknown,
  func?: unknown,
  dict?: unknown,
): Promise<unknown>;
export function uniq(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("uniq", ...args);
}

/**
 * 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`:
 *
 *     mydict->values()
 */
export function values(denops: Denops, dict: unknown): Promise<unknown>;
export function values(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("values", ...args);
}

/**
 * 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`:
 *
 *     GetWinid()->virtcol2col(lnum, col)
 */
export function virtcol2col(
  denops: Denops,
  winid: unknown,
  lnum: unknown,
  col: unknown,
): Promise<unknown>;
export function virtcol2col(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("virtcol2col", ...args);
}

/**
 * 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:
 *
 *     :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`.
 */
export function visualmode(denops: Denops, expr?: unknown): Promise<unknown>;
export function visualmode(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("visualmode", ...args);
}

/**
 * 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:
 *
 *     :cnoremap <expr> <C-j> wildmenumode() ? "\<Down>\<Tab>" : "\<c-j>"
 *
 * (Note, this needs the 'wildcharm' option set appropriately).
 */
export function wildmenumode(denops: Denops): Promise<unknown>;
export function wildmenumode(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("wildmenumode", ...args);
}

/**
 * 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:
 *
 *     call win_execute(winid, 'set syntax=python')
 *
 * Doing the same with `setwinvar()` would not trigger
 * autocommands and not actually show syntax highlighting.
 *
 * Not all commands are allowed in popup windows.
 * 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:
 *
 *     GetCommand()->win_execute(winid)
 */
export function win_execute(
  denops: Denops,
  id: unknown,
  command: unknown,
  silent?: unknown,
): Promise<unknown>;
export function win_execute(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("win_execute", ...args);
}

/**
 * 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`:
 *
 *     GetBufnr()->win_findbuf()
 */
export function win_findbuf(denops: Denops, bufnr: unknown): Promise<unknown>;
export function win_findbuf(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("win_findbuf", ...args);
}

/**
 * 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`:
 *
 *     GetWinnr()->win_getid()
 */
export function win_getid(
  denops: Denops,
  win?: unknown,
  tab?: unknown,
): Promise<unknown>;
export function win_getid(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("win_getid", ...args);
}

/**
 * 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"         popup window `popup`
 *         "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.  When running a terminal in a
 * popup window then 'buftype' is "terminal" and win_gettype()
 * returns "popup".
 *
 * Can also be used as a `method`:
 *
 *     GetWinid()->win_gettype()
 */
export function win_gettype(denops: Denops, nr?: unknown): Promise<unknown>;
export function win_gettype(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("win_gettype", ...args);
}

/**
 * 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`:
 *
 *     GetWinid()->win_gotoid()
 */
export function win_gotoid(denops: Denops, expr: unknown): Promise<unknown>;
export function win_gotoid(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("win_gotoid", ...args);
}

/**
 * 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`:
 *
 *     GetWinid()->win_id2tabwin()
 */
export function win_id2tabwin(denops: Denops, expr: unknown): Promise<unknown>;
export function win_id2tabwin(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("win_id2tabwin", ...args);
}

/**
 * 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`:
 *
 *     GetWinid()->win_id2win()
 */
export function win_id2win(denops: Denops, expr: unknown): Promise<unknown>;
export function win_id2win(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("win_id2win", ...args);
}

/**
 * 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.
 *
 * Can also be used as a `method`:
 *
 *     GetWinnr()->win_move_separator(offset)
 */
export function win_move_separator(
  denops: Denops,
  nr: unknown,
  offset: unknown,
): Promise<unknown>;
export function win_move_separator(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("win_move_separator", ...args);
}

/**
 * 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.
 *
 * Can also be used as a `method`:
 *
 *     GetWinnr()->win_move_statusline(offset)
 */
export function win_move_statusline(
  denops: Denops,
  nr: unknown,
  offset: unknown,
): Promise<unknown>;
export function win_move_statusline(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("win_move_statusline", ...args);
}

/**
 * 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`:
 *
 *     GetWinid()->win_screenpos()
 */
export function win_screenpos(denops: Denops, nr: unknown): Promise<unknown>;
export function win_screenpos(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("win_screenpos", ...args);
}

/**
 * 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`:
 *
 *     GetWinid()->win_splitmove(target)
 */
export function win_splitmove(
  denops: Denops,
  nr: unknown,
  target: unknown,
  options?: unknown,
): Promise<unknown>;
export function win_splitmove(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("win_splitmove", ...args);
}

/**
 * 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:
 *
 *     :echo "The file in the current window is " . bufname(winbufnr(0))
 *
 * Can also be used as a `method`:
 *
 *     FindWindow()->winbufnr()->bufname()
 */
export function winbufnr(denops: Denops, nr: unknown): Promise<unknown>;
export function winbufnr(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("winbufnr", ...args);
}

/**
 * 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.
 */
export function windowsversion(denops: Denops): Promise<unknown>;
export function windowsversion(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("windowsversion", ...args);
}

/**
 * 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:
 *
 *     :echo "The current window has " .. winheight(0) .. " lines."
 *
 * Can also be used as a `method`:
 *
 *     GetWinid()->winheight()
 */
export function winheight(denops: Denops, nr: unknown): Promise<unknown>;
export function winheight(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("winheight", ...args);
}

/**
 * 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:
 *
 *     " 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`:
 *
 *     GetTabnr()->winlayout()
 */
export function winlayout(denops: Denops, tabnr?: unknown): Promise<unknown>;
export function winlayout(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("winlayout", ...args);
}

/**
 * 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:
 *
 *     let window_count = winnr('$')
 *     let prev_window = winnr('#')
 *     let wnum = winnr('3k')
 *
 * Can also be used as a `method`:
 *
 *     GetWinval()->winnr()
 */
export function winnr(denops: Denops, arg?: unknown): Promise<unknown>;
export function winnr(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("winnr", ...args);
}

/**
 * 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:
 *
 *     :let cmd = winrestcmd()
 *     :call MessWithWindowSizes()
 *     :exe cmd
 */
export function winrestcmd(denops: Denops): Promise<unknown>;
export function winrestcmd(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("winrestcmd", ...args);
}

/**
 * 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:
 *
 *     :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`:
 *
 *     GetView()->winrestview()
 */
export function winrestview(denops: Denops, dict: unknown): Promise<unknown>;
export function winrestview(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("winrestview", ...args);
}

/**
 * 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.
 */
export function winsaveview(denops: Denops): Promise<unknown>;
export function winsaveview(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("winsaveview", ...args);
}

/**
 * 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:
 *
 *     :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`:
 *
 *     GetWinid()->winwidth()
 */
export function winwidth(denops: Denops, nr: unknown): Promise<unknown>;
export function winwidth(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("winwidth", ...args);
}

/**
 * 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)
 */
export function wordcount(denops: Denops): Promise<unknown>;
export function wordcount(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("wordcount", ...args);
}

/**
 * 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:
 *
 *     :call writefile(["foo"], "event.log", "a")
 *     :call writefile(["bar"], "event.log", "a")
 *
 * 'D'  Delete the file when the current function ends.  This
 *      works like:
 *
 *          :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:
 *
 *     :let fl = readfile("foo", "b")
 *     :call writefile(fl, "foocopy", "b")
 *
 * Can also be used as a `method`:
 *
 *     GetText()->writefile("thefile")
 */
export function writefile(
  denops: Denops,
  object: unknown,
  fname: unknown,
  flags?: unknown,
): Promise<unknown>;
export function writefile(
  denops: Denops,
  ...args: unknown[]
): Promise<unknown> {
  return denops.call("writefile", ...args);
}

/**
 * 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:
 *
 *     :let bits = xor(bits, 0x80)
 *
 * Can also be used as a `method`:
 *
 *     :let bits = bits->xor(0x80)
 */
export function xor(
  denops: Denops,
  expr1: unknown,
  expr2: unknown,
): Promise<unknown>;
export function xor(denops: Denops, ...args: unknown[]): Promise<unknown> {
  return denops.call("xor", ...args);
}