nixeovim/modules/vim/options.nix

{ lib }:

let
  inherit (builtins) mapAttrs;
  mkVimOptOption =
    key:
    { type
    , default
    , description ? ""
    , extraHelp ? [ ]
    , apply ? null
    }:
    lib.mkOption {
      type = lib.types.nullOr type;
      inherit apply;
      default = null;
      defaultText = lib.literalExpression (builtins.toJSON default);
      description = lib.concatLines (
        [ description "" ]
        ++ map (help: "`:help ${help}") ([ key ] ++ extraHelp)
      );
    };


  sharedGlobalOrWindow = with lib; with types; {
    fillchars = {
      type = (listOf (enum [
        "stl"
        "stlnc"
        "wbr"
        "horiz"
        "horizup"
        "horizdown"
        "vert"
        "vertleft"
        "vertright"
        "verthoriz"
        "fold"
        "foldopen"
        "foldclose"
        "foldsep"
        "diff"
        "msgsep"
        "eob"
        "lastline"
      ]));
      default = [ ];
      description = ''
        Characters to fill the statuslines, vertical separators and special lines in the window.
      '';
    };
  };

  sharedGlobalOrBuffer = with lib; with types; {
    autoread = {
      type = bool;
      description = ''
        When a file has been detected to have been changed outside of Vim and
        it has not been changed inside of Vim, automatically read it again.
        When the file has been deleted this is not done, so you have the text
        from before it was deleted.  When it appears again then it is read.
        |timestamp|
      '';
    };

    backupcopy = {
      type = (listOf (enum [ "yes" "no" "auto" "breaksymlink" "breakhardlink" ]));
      description = ''
        When writing a file and a backup is made, this option tells how it's
        done.  This is a comma-separated list of words.
      '';
    };

    formatprg = {
      type = str;
      default = "";
      description = ''
        The name of an external program that will be used to format the lines
        selected with the |gq| operator.  The program must take the input on
        stdin and produce the output on stdout.
      '';
    };

    grepprg = {
      type = str;
      default = ''
        default "grep -n ",
        Unix: "grep -n $* /dev/null"
      '';
    };

    include = {
      type = str;
      default = ''^\s*#\s*include'';
      description = ''
        Pattern to be used to find an include command.
      '';
    };

    keywordprg = {
      type = str;
      default = ''
        Windows: ":help"
        otherwise: ":Man"
      '';
      description = ''
        Program to use for the |K| command.
      '';
    };

    lispwords = {
      type = (listOf str);
      default = is very long;
      description = ''
        list of words that influence the Lisp indenting when
        enabled with the |'lisp'| option.
      '';
    };

    makeencoding = {
      type = str;
      default = "";
      description = ''
        Encoding used for reading the output of external commands.  When empty,
        encoding is not converted.
        This is used for `:make`, `:lmake`, `:grep`, `:lgrep`, `:grepadd`,
        `:lgrepadd`, `:cfile`, `:cgetfile`, `:caddfile`, `:lfile`, `:lgetfile`,
        and `:laddfile`.
 
      '';
    };
  };

  global = with lib; with types; sharedGlobalOrWindow // sharedGlobalOrBuffer // {
    allowrevins = {
      type = bool;
      description = ''
        Allow CTRL-_ in Insert and Command-line mode.  This is default off, to
        avoid that users that accidentally type CTRL-_ instead of SHIFT-_ get
        into reverse Insert mode, and don't know how to get out.  See
 
      '';
    };

    ambiwidth = {
      type = (enum [ "single" "double" ]);
      description = ''
        Tells Vim what to do with characters with East Asian Width Class
        Ambiguous (such as Euro, Registered Sign, Copyright Sign, Greek
        letters, Cyrillic letters).
 
      '';
    };

    autochdir = {
      type = bool;
      description = ''
        When on, Vim will change the current working directory whenever you
        open a file, switch buffers, delete a buffer or open/close a window.
        It will change to the directory containing the file which was opened
        or selected.  When a buffer has no name it also has no directory, thus
        the current directory won't change when navigating to it.
        Note: When this option is on some plugins may not work.
 
      '';
    };

    arabicshape = {
      type = bool;
      default = false;
      description = ''
        When on and 'termbidi' is off, the required visual character
        corrections that need to take place for displaying the Arabic language
        take effect.
 
      '';
    };

    autowrite = {
      type = bool;
      description = ''
        Write the contents of the file, if it has been modified, on each
        `:next`, `:rewind`, `:last`, `:first`, `:previous`, `:stop`,
        `:suspend`, `:tag`, `:!`, `:make`, CTRL-] and CTRL-^ command; and when
        a `:buffer`, CTRL-O, CTRL-I, '{A-Z0-9}, or `{A-Z0-9} command takes one
        to another file.
 
      '';
    };

    autowriteall = {
      type = bool;
      description = ''
        	Like 'autowrite', but also used for commands ":edit", ":enew", ":quit",
        	":qall", ":exit", ":xit", ":recover" and closing the Vim window.
        	Setting this option also implies that Vim behaves like 'autowrite' has
        	been set. 
      '';
    };

    background = {
      type = str;
      description = ''
        When set to "dark" or "light", adjusts the default color groups for
        that background type.  The |TUI| or other UI sets this on startup
        (triggering |OptionSet|) if it can detect the background color.

        This option does NOT change the background color, it tells Nvim what
        the "inherited" (terminal/GUI) background looks like.
        See |:hi-normal| if you want to set the background color explicitly.

        When a color scheme is loaded (the "g:colors_name" variable is set)
        setting 'background' will cause the color scheme to be reloaded.  If
        the color scheme adjusts to the value of 'background' this will work.
        However, if the color scheme sets 'background' itself the effect may
        be undone.  First delete the "g:colors_name" variable when needed.
 
      '';
    };

    backspace = {
      type = (listOf (enum [ "indent" "eol" "start" "nostop" ]));
      description = ''
        Influences the working of <BS>, <Del>, CTRL-W and CTRL-U in Insert
        mode.  This is a list of items, separated by commas.  Each item allows
        a way to backspace over something:
 
      '';
    };

    backup = {
      type = bool;
      description = ''
        Make a backup before overwriting a file.  Leave it around after the
        file has been successfully written.  If you do not want to keep the
        backup file, but you do want a backup while the file is being
        written, reset this option and set the 'writebackup' option (this is
        the default).  If you do not want a backup file at all reset both
        options (use this if your file system is almost full).  See the
        |backup-table| for more explanations.
      '';
      extraHelp = [ "backup-table" ];
    };

    backupdir = {
      type = (listOf (either str path));
      description = ''
        List of directories for the backup file, separated with commas.
 
      '';
    };

    backupext = {
      type = str;
      description = ''
        str which is appended to a file name to make the name of the
        backup file.  The default is quite unusual, because this avoids
        accidentally overwriting existing files with a backup file.  You might
        prefer using ".bak", but make sure that you don't have files with
        ".bak" that you want to keep.
        Only normal file name characters can be used; "/\*?[|<>" are illegal.
 
      '';
    };

    backupskip = {
      type = (listOf (either str path));
      description = ''
        A list of file patterns.  When one of the patterns matches with the
        name of the file which is written, no backup file is created.  Both
        the specified file name and the full path name of the file are used.
        The pattern is used like with |:autocmd|, see |autocmd-pattern|.
        Watch out for special characters, see |option-backslash|.
        When $TMPDIR, $TMP or $TEMP is not defined, it is not used for the
        default value.  "/tmp/*" is only used for Unix.
 
      '';
    };

    belloff = {
      type = (listOf (enum [
        "all"
        "backspace"
        "cursor"
        "complete"
        "copy"
        "ctrlg"
        "error"
        "esc"
        "hangul"
        "lang"
        "mess"
        "showmatch"
        "operator"
        "register"
        "shell"
        "spell"
        "willmode"
      ]));
      description = ''
        Specifies for which events the bell will not be rung. It is a comma-
        separated list of items. For each item that is present, the bell
        will be silenced. This is most useful to specify specific events in
        insert mode to be silenced.

        item	    |  meaning when present	 
        --------------------------------------------------------------------
        all	      | All events.
        backspace | When hitting <BS> or <Del> and deleting results in an error.
        cursor	  | Fail to move around using the cursor keys or
                  | <PageUp>/<PageDown> in |Insert-mode|.
        complete  | Error occurred when using |i_CTRL-X_CTRL-K| or
                  | |i_CTRL-X_CTRL-T|.
        copy	    | Cannot copy char from insert mode using |i_CTRL-Y| or
                  | |i_CTRL-E|.
        ctrlg	    | Unknown Char after <C-G> in Insert mode.
        error	    | Other Error occurred (e.g. try to join last line)
                  | (mostly used in |Normal-mode| or |Cmdline-mode|).
        esc	      | hitting <Esc> in |Normal-mode|.
        hangul	  | Ignored.
        lang	    | Calling the beep module for Lua/Mzscheme/TCL.
        mess	    | No output available for |g<|.
        showmatch | Error occurred for 'showmatch' function.
        operator  | Empty region error |cpo-E|.
        register  | Unknown register after <C-R> in |Insert-mode|.
        shell	    | Bell from shell output |:!|.
        spell	    | Error happened on spell suggest.
        wildmode  | More matches in |cmdline-completion| available
                  | (depends on the 'wildmode' setting).
 
      '';
    };

    breakat = {
      type = str;
      description = ''
        This option lets you choose which characters might cause a line
        break if 'linebreak' is on.  Only works for ASCII characters.
 
      '';
    };

    browsedir = {
      type = (either path (enum [ "last" "buffer" "current" ]));
      description = ''
        Which directory to use for the file browser:
        last		Use same directory as with last file browser, where a file was opened or saved.
        buffer	Use the directory of the related buffer.
        current	Use the current directory.
        {path}	Use the specified directory
 
      '';
    };

    casemap = {
      type = (listOf (enum [ "internal" "keepascii" ]));
      description = ''
        Specifies details about changing the case of letters.  It may contain
        these words, separated by a comma:
        - internal -	Use internal case mapping functions, the current locale does not change the case
          mapping. When "internal" is omitted, the towupper() and towlower() system library functions are
          used when available.
        - keepascii - For the ASCII characters (0x00 to 0x7f) use the US case mapping, the current locale
          is not effective. This probably only matters for Turkish.
 
      '';
    };

    cedit = {
      type = str;
      description = ''
        The key used in Command-line Mode to open the command-line window.
        Only non-printable keys are allowed.
 
      '';
    };

    charconvert = {
      type = str;
      default = "";
      description = ''
        An expression that is used for character encoding conversion.  It is
        evaluated when a file that is to be read or has been written has a
        different encoding from what is desired.
 
      '';
    };

    clipboard = {
      type = (listOf (enum [ "unnamed" "unnamedplus" ]));
      description = ''
        This option is a list of comma-separated names.
 
      '';
    };

    cmdheight = {
      type = number;
      description = ''
        Number of screen lines to use for the command-line.  Helps avoiding |hit-enter| prompts.
 
      '';
    };

    cmdwinheight = {
      type = number;
      description = ''
        Number of screen lines to use for the command-line window. 
      '';
      extraHelp = [ "cmdwin" ];
    };

    completeopt = {
      type = (listOf (enum [
        "menu"
        "menuone"
        "longest"
        "preview"
        "noinsert"
        "noselect"
      ]));
      description = ''
        A comma-separated list of options for Insert mode completion |ins-completion|.
 
      '';
    };

    confirm = {
      type = bool;
      description = ''
        When 'confirm' is on, certain operations that would normally
        fail because of unsaved changes to a buffer, e.g. ":q" and ":e",
        instead raise a dialog asking if you wish to save the current
        file(s).  You can still use a ! to unconditionally |abandon| a buffer.
        If 'confirm' is off you can still activate confirmation for one
        command only (this is most useful in mappings) with the |:confirm|
        command.
 
      '';
    };

    cpoptions = {
      type = str;
      default = true;
      description = ''
        A sequence of single character flags.  When a character is present
        this indicates Vi-compatible behavior.  This is used for things where
        not being Vi-compatible is mostly or sometimes preferred.
        'cpoptions' stands for "compatible-options".
        Commas can be added for readability.
 
      '';
    };

    debug = {
      type = (listOf (enum [ "msg" "throw" "beep" ]));
      description = ''
        These values can be used:
        - msg	Error messages that would otherwise be omitted will be given anyway.
        - throw	Error messages that would otherwise be omitted will be given anyway and also throw an exception and set |v:errmsg|.
        - beep	A message will be given when otherwise only a beep would be produced.

        The values can be combined, separated by a comma.
        "msg" and "throw" are useful for debugging 'foldexpr', 'formatexpr' or
        'indentexpr'.
 
      '';
    };

    define = {
      type = str;
      description = ''
        Pattern to be used to find a macro definition.
 
      '';
    };

    delcombine = {
      type = bool;
      description = ''
        If editing Unicode and this option is set, backspace and Normal mode
        "x" delete each combining character on its own.  When it is off (the
        default) the character along with its combining characters are
        deleted.
 
      '';
    };

    dictionary = {
      type = (listOf (either str path));
      description = ''
        List of file names, separated by commas, that are used to lookup words
        for keyword completion commands |i_CTRL-X_CTRL-K|.  Each file should
        contain a list of words.  This can be one word per line, or several
        words per line, separated by non-keyword characters (white space is
        preferred).  Maximum line length is 510 bytes.
 
      '';
    };

    diffexpr = {
      type = str;
      description = ''
        Expression which is evaluated to obtain a diff file (either ed-style
        or unified-style) from two versions of a file.
 
      '';
      extraHelp = [ "diff-diffexpr" ];
    };

    diffopt = {
      type = (listOf str);
      description = ''
        Option settings for diff mode.
 
      '';
    };

    digraph = {
      type = bool;
      description = ''
        Enable the entering of digraphs in Insert mode with {char1} <BS> {char2}.
 
      '';
      extraHelp = [ "digraphs" ];
    };

    directory = {
      type = (listOf (either str path));
      description = ''
        List of directory names for the swap file, separated with commas.
 
      '';
    };

    display = {
      type = (listOf (enum [ "lastline" "truncate" "uhex" "msgsep" ]));
      description = ''
        Change the way text is displayed.
 
      '';
    };

    eadirection = {
      type = (enum [ "ver" "hor" "both" ]);
      description = ''
        Tells when the 'equalalways' option applies:
 
      '';
    };

    emoji = {
      type = bool;
      description = ''
        When on all Unicode emoji characters are considered to be full width.
        This excludes "text emoji" characters, which are normally displayed as
        single width.
 
      '';
    };

    equalalways = {
      type = bool;
      description = ''
        When on, all the windows are automatically made the same size after
        splitting or closing a window.  This also happens the moment the
        option is switched on.  When off, splitting a window will reduce the
        size of the current window and leave the other windows the same.
 
      '';
    };

    equalprg = {
      type = str;
      description = ''
        External program to use for "=" command.  When this option is empty
        the internal formatting functions are used; either 'lisp', 'cindent'
        or 'indentexpr'.
 
      '';
    };

    errorbells = {
      type = bool;
      default = false;
      description = ''
        Ring the bell (beep or screen flash) for error messages.  This only
        makes a difference for error messages, the bell will be used always
        for a lot of errors without a message
 
      '';
    };

    errorfile = {
      type = str;
      default = "errors.err";
      description = ''
        Name of the errorfile for the QuickFix mode.
 
      '';
      extraHelp = [ "cf" ];
    };

    errorformat = {
      type = str;
      description = ''
        Scanf-like description of the format for the lines in the error file
 
      '';
    };

    eventignore = {
      type = (listOf str);
      default = [ ];
      description = ''
        A list of autocommand event names, which are to be ignored.
        When set to "all" or when "all" is one of the items, all autocommand
        events are ignored, autocommands will not be executed.
 
      '';
    };

    exrc = {
      type = bool;
      default = false;
      description = ''
        Automatically execute .nvim.lua, .nvimrc, and .exrc files in the
        current directory, if the file is in the |trust| list. Use |:trust| to
        manage trusted files.
 
      '';
      extraHelp = [ ":trust" ];
    };

    fileencodings = {
      type = (listOf str);
      default = ''["ucs-bom" "utf-8" "default" "latin1"]'';
      description = ''
        This is a list of character encodings considered when starting to edit
        an existing file.
 
      '';
    };

    fileformats = {
      type = (listOf (enum [ "dos" "unix" "mac" ]));
      default = ''
        Windows default: ["dos" "unix"],
        Unix default: ["unix" "dos"]
      '';
      description = ''
        This gives the end-of-line (<EOL>) formats that will be tried when
        starting to edit a new buffer and when reading a file into an existing
        buffer
 
      '';
    };

    fileignorecase = {
      type = bool;
      default = ''
        `true` for systems where case in file names is normally ignored"
      '';
      description = ''
        When set case is ignored when using file names and directories.
 
      '';
    };

    foldclose = {
      type = str;
      default = "";
      description = ''
        When set to "all", a fold is closed when the cursor isn't in it and
        its level is higher than 'foldlevel'.  Useful if you want folds to
        automatically close when moving out of them.
 
      '';
    };

    foldlevelstart = {
      type = number;
      default = -1;
      description = ''
        Sets 'foldlevel' when starting to edit another buffer in a window.
        Useful to always start editing with all folds closed (value zero),
        some folds closed (one) or no folds closed (99).

        When the value is negative, it is not used.
 
      '';
      extraHelp = [ "foldlevel" ];
    };

    foldopen = {
      type = (listOf (enum [
        "all"
        "block"
        "hor"
        "insert"
        "jump"
        "mark"
        "percent"
        "quickfix"
        "search"
        "tag"
        "undo"
      ]));
      default = ''
        [
          "block"
          "hor"
          "mark"
          "percent"
          "quickfix"
          "search"
          "tag"
          "undo"
        ]
      '';
      description = ''
        Specifies for which type of commands folds will be opened, if the
        command moves the cursor into a closed fold.  It is a comma-separated
        list of items.
 
      '';
    };

    fsync = {
      type = bool;
      default = true;
      description = ''
        When on, the OS function fsync() will be called after saving a file
        (|:write|, |writefile()|, …), |swap-file|, |undo-persistence| and |shada-file|.
        This flushes the file to disk, ensuring that it is safely written.
        Slow on some systems: writing buffers, quitting Nvim, and other
        operations may sometimes take a few seconds.
 
      '';
    };

    gdefault = {
      type = bool;
      default = false;
      description = ''
        When on, the ":substitute" flag 'g' is default on.  This means that
        all matches in a line are substituted instead of one.  When a 'g' flag
        is given to a ":substitute" command, this will toggle the substitution
        of all or one match.  See |complex-change|.
 
      '';
    };

    grepformat = {
      type = str;
      default = ''%f:%l:%m,%f:%l%m,%f  %l%m'';
      description = ''
        Format to recognize for the ":grep" command output.
 
      '';
      extraHelp = [ "errorformat" ];
    };

    guicursor = {
      type = str;
      default = "n-v-c-sm:block,i-ci-ve:ver25,r-cr-o:hor20";
      description = ''
        Configures the cursor style for each mode. Works in the GUI and many
        terminals.  See |tui-cursor-shape|.

        To disable cursor-styling, reset the option
 
      '';
    };

    guifont = {
      type = (listOf str);
      default = [ ];
      description = ''
        This is a list of fonts which will be used for the GUI version of Vim.
        In its simplest form the value is just one font name.  When
        the font cannot be found you will get an error message.  To try other
        font names a list can be specified, font names separated with commas.
        The first valid font is used.
 
      '';
    };

    guifontwide = {
      type = (listOf str);
      default = [ ];
      description = ''
        list of fonts to be used for double-width characters.
        The first font that can be loaded is used.
 
      '';
    };

    guioptions = {
      type = str;
      default = "egmrLT";
      description = ''
        This option only has an effect in the GUI version of Vim.  It is a
        sequence of letters which describes what components and options of the
        GUI should be used.
 
      '';
    };

    guitablabel = {
      type = str;
      default = "";
      description = ''
        When non-empty describes the text to use in a label of the GUI tab
        pages line.  When empty and when the result is empty Vim will use a
        default label.
 
      '';
      extraHelp = [ "setting-guitablabel" ];
    };

    guitabtooltip = {
      type = str;
      default = "";
      description = ''
        When non-empty describes the text to use in a tooltip for the GUI tab
        pages line.  When empty Vim will use a default tooltip.
 
      '';
    };

    helpfile = {
      type = (either str path);
      default = ''
        default (MS-Windows) "$VIMRUNTIME\doc\help.txt"
                (others) "$VIMRUNTIME/doc/help.txt"
 
      '';
    };

    helpheight = {
      type = number;
      default = 20;
      description = ''
        Minimal initial height of the help window when it is opened with the ":help" command.
 
      '';
    };

    helplang = {
      type = (listOf str);
      default = messages language or empty;
      description = ''
        list of languages.  Vim will use the first language
        for which the desired help can be found.
 
      '';
    };

    hidden = {
      type = bool;
      default = true;
      description = ''
        When off a buffer is unloaded (including loss of undo information)
        when it is abandoned.  When on a buffer becomes hidden when it is
        abandoned.  A buffer displayed in another window does not become
        hidden, of course.
 
      '';
      extraHelp = [
        "abadon"
        "bufhidden"
      ];
    };

    history = {
      type = number;
      default = 10000;
      description = ''
        A history of ":" commands, and a history of previous search patterns
        is remembered.  This option decides how many entries may be stored in
        each of these histories

        The maximum is 10000.
 
      '';
      extraHelp = [ "cmdline-editing" ];
    };

    hlsearch = {
      type = bool;
      default = true;
      description = ''
        When there is a previous search pattern, highlight all its matches.
 
      '';
      extraHelp = [
        "incsearch"
        "match"
      ];
    };

    icon = {
      type = bool;
      default = false;
      description = ''
        When on, the icon text of the window will be set to the value of
        'iconstr' (if it is not empty), or to the name of the file
        currently being edited.  Only the last part of the name is used.
        Overridden by the 'iconstr' option.
        Only works if the terminal supports setting window icons.
 
      '';
      extraHelp = [ "iconstring" ];
    };

    iconstring = {
      type = str;
      default = "";
      description = ''
        When this option is not empty, it will be used for the icon text of the window.
 
      '';
    };

    ignorecase = {
      type = bool;
      default = false;
      description = ''
        Ignore case in search patterns.  Also used when searching in the tags file.

        Also see 'smartcase' and 'tagcase'.
 
      '';
    };

    imcmdline = {
      type = bool;
      default = false;
      description = ''
        When set the Input Method is always on when starting to edit a command
        line, unless entering a search pattern.
 
      '';
      extraHelp = [ "imsearch" ];
    };

    imdisable = {
      type = bool;
      default = ''
        false
        true for some systems (SGI)
      '';
      description = ''
        When set the Input Method is never used.  This is useful to disable
        the IM when it doesn't work properly.
 
      '';
    };

    inccommand = {
      type = (enum [ "nosplit" "split" ]);
      default = "nosplit";
      description = ''
        When nonempty, shows the effects of |:substitute|, |:smagic|,
        |:snomagic| and user commands with the |:command-preview| flag as you
        type.
 
      '';
    };

    incsearch = {
      type = bool;
      default = true;
      description = ''
        While typing a search command, show where the pattern, as it was typed
        so far, matches.  The matched str is highlighted.  If the pattern
        is invalid or not found, nothing is shown.
 
      '';
    };

    isfname = {
      type = str;
      default = ''
        Windows: "@,48-57,/,\,.,-,_,+,,,#,$,%,{,},[,],:,@-@,!,~,="
        otherwise: "@,48-57,/,.,-,_,+,,,#,$,%,~,="
      '';
    };

    isident = {
      type = str;
      default = ''
        Windows: "@,48-57,_,128-167,224-235"
        otherwise: "@,48-57,_,192-255"
      '';
      description = ''
        The characters given by this option are included in identifiers.
        Identifiers are used in recognizing environment variables and after a
        match of the 'define' option.
 
      '';
    };

    isprint = {
      type = str;
      default = "@,161-255";
      description = ''
        The characters given by this option are displayed directly on the
        screen.  It is also used for "\p" in a |pattern|.
 
      '';
      extraHelp = [ "pattern" ];
    };

    jumpoptions = {
      type = str;
      default = "";
      description = ''
        List of words that change the behavior of the |jumplist|
 
      '';
      extraHelp = [ "jumplist" ];
    };

    joinspaces = {
      type = bool;
      default = false;
      description = ''
        Insert two spaces after a '.', '?' and '!' with a join command.
        Otherwise only one space is inserted.
 
      '';
    };

    keymodel = {
      type = (listOf str);
      default = [ ];
      description = ''
        List of comma-separated words, which enable special things that keys can do.
 
      '';
    };

    langmap = {
      type = (listOf str);
      default = [ ];
      description = ''
        This option allows switching your keyboard into a special language
        mode.  When you are typing text in Insert mode the characters are
        inserted directly.  When in Normal mode the 'langmap' option takes
        care of translating these special characters to the original meaning
        of the key.  This means you don't have to change the keyboard mode to
        be able to execute Normal mode commands.
 
      '';
    };

    langmenu = {
      type = str;
      default = "";
      description = ''
        Language to use for menu translation.
 
      '';
    };

    langremap = {
      type = bool;
      default = false;
      description = ''
        When off, setting 'langmap' does not apply to characters resulting from
        a mapping.  If setting 'langmap' disables some of your mappings, make
        sure this option is off.
 
      '';
    };

    laststatus = {
      type = number;
      default = 2;
      description = ''
        The value of this option influences when the last window will have a
        status line:
        - 0: never
        - 1: only if there are at least two windows
        - 2: always
        - 3: always and ONLY the last window
 
      '';
    };

    lazyredraw = {
      type = bool;
      default = false;
      description = ''
        When this option is set, the screen will not be redrawn while
        executing macros, registers and other commands that have not been
        typed.  Also, updating the window title is postponed.  To force an
        update use |:redraw|.
 
      '';
      extraHelp = [ ":redraw" ];
    };

    linespace = {
      type = number;
      default = 0;
      description = ''
        Number of pixel lines inserted between characters.  Useful if the font
        uses the full character cell height, making lines touch each other.
        When non-zero there is room for underlining.
 
      '';
    };

    loadplugins = {
      type = bool;
      default = true;
      description = ''
        When on the plugin scripts are loaded when starting up |load-plugins|.
        This option can be reset in your |vimrc| file to disable the loading
        of plugins.
 
      '';
    };

    magic = {
      type = bool;
      default = true;
      description = ''
        Changes the special characters that can be used in search patterns.
        See |pattern|.
        WARNING: Switching this option off most likely breaks plugins!  That
        is because many patterns assume it's on and will fail when it's off.
 
      '';
    };

    makeef = {
      type = (either str path);
      default = "";
      description = ''
        Name of the errorfile for the |:make| command (see |:make_makeprg|)
        and the |:grep| command.
        When it is empty, an internally generated temp file will be used.
        When "##" is included, it is replaced by a number to make the name
        unique.
 
      '';
    };
  };

  window = with lib; with types; sharedGlobalOrWindow // {
    arabic = {
      type = bool;
      default = false;
      description = ''
        This option can be set to start editing Arabic text.
 
      '';
    };

    breakindent = {
      type = bool;
      default = false;
      description = ''
        Every wrapped line will continue visually indented (same amount of
        space as the beginning of that line), thus preserving horizontal blocks
        of text.
 
      '';
    };

    breakindentopt = {
      type = commas;
      default = [ ];
      description = ''
        Settings for 'breakindent
 
      '';
    };

    colorcolumn = {
      type = commas;
      default = [ ];
      description = ''
        'colorcolumn' is a comma-separated list of screen columns that are
        highlighted with ColorColumn |hl-ColorColumn|.  Useful to align
        text.  Will make screen redrawing slower.
 
      '';
    };

    concealcursor = {
      type = str;
      default = "";
      description = ''
        Sets the modes in which text in the cursor line can also be concealed.
 
      '';
    };

    conceallevel = {
      type = number;
      default = 0;
      description = ''
        Determine how text with the "conceal" syntax attribute |:syn-conceal|
        is shown
 
      '';
      extraHelp = [ "syn-conceal" ];
    };

    cursorbind = {
      type = bool;
      default = false;
      description = ''
        When this option is set, as the cursor in the current
        window moves other cursorbound windows (windows that also have
        this option set) move their cursors to the corresponding line and
        column.
 
      '';
    };

    foldcolumn = {
      type = str;
      default = "0";
      description = ''
        When and how to draw the foldcolumn. Valid values are:
            "auto":       resize to the minimum amount of folds to display.
            "auto:[1-9]": resize to accommodate multiple folds up to the selected level
            "0":          to disable foldcolumn
            "[1-9]":      to display a fixed number of columns
 
      '';
      extraHelp = [ "folding" ];
    };

    foldenable = {
      type = bool;
      default = false;
      description = ''
        When off, all folds are open.  This option can be used to quickly
        switch between showing all text unfolded and viewing the text with
        folds (including manually opened or closed folds).  It can be toggled
        with the |zi| command.  The 'foldcolumn' will remain blank when
        'foldenable' is off.
 
      '';
      extraHelp = [ "folding" ];
    };

    foldexpr = {
      type = str;
      default = "0";
      description = ''
        The expression used for when 'foldmethod' is "expr".  It is evaluated
        for each line to obtain its fold level.
 
      '';
      extraHelp = [ "fold-expr" ];
    };

    foldignore = {
      type = str;
      default = "#";
      description = ''
        Used only when 'foldmethod' is "indent".  Lines starting with
        characters in 'foldignore' will get their fold level from surrounding
        lines.  White space is skipped before checking for this character.
 
      '';
      extraHelp = [ "fold-indent" ];
    };

    foldlevel = {
      type = number;
      default = 0;
      description = ''
        Sets the fold level: Folds with a higher level will be closed.
        Setting this option to zero will close all folds.  Higher numbers will
        close fewer folds.
        This option is set by commands like |zm|, |zM| and |zR|.
 
      '';
      extraHelp = [ "fold-foldlevel" ];
    };

    foldmarker = {
      type = (listOf str);
      apply = x: assert (x == null || builtins.length x == 2 || abort "`foldmarker` must contain start and end markers in the list"); x;
      default = ''["{{{" "}}}"]'';
      description = ''
        The start and end marker used when 'foldmethod' is "marker".
 
      '';
    };

    foldmethod = {
      type = (enum [ "manual" "indent" "expr" "marker" "syntax" "diff" ]);
      default = "manual";
      description = ''
        The kind of folding used for the current window.
      '';
      extraHelp = [
        "fold-manual"
        "fold-indent"
        "fold-expr"
        "fold-marker"
        "fold-syntax"
        "fold-diff"
      ];
    };

    foldminlines = {
      type = number;
      default = 1;
      description = ''
        Sets the number of screen lines above which a fold can be displayed
        closed.  Also for manually closed folds.
 
      '';
    };

    foldnestmax = {
      type = number;
      default = 20;
      description = ''
        Sets the maximum nesting of folds for the "indent" and "syntax"
        methods.  This avoids that too many folds will be created.  Using more
        than 20 doesn't work, because the internal limit is 20.
 
      '';
    };

    foldtext = {
      type = str;
      default = "foldtext()";
      description = ''
        An expression which is used to specify the text displayed for a closed fold.
 
      '';
      extraHelp = [ "fold-foldtext" ];
    };

    linebreak = {
      type = bool;
      default = false;
      description = ''
        If on, Vim will wrap long lines at a character in 'breakat' rather
        than at the last character that fits on the screen.  Unlike
        'wrapmargin' and 'textwidth', this does not insert <EOL>s in the file,
        it only affects the way the file is displayed, not its contents.
 
      '';
    };

    list = {
      type = bool;
      default = false;
      description = ''
        List mode: By default, show tabs as ">", trailing spaces as "-", and
        non-breakable space characters as "+". Useful to see the difference
        between tabs and spaces and for trailing blanks. Further changed by
        the 'listchars' option.
 
      '';
      extraHelp = [ "listchars" ];
    };

    listchars = {
      type = submodule {
        options =
          let
            inherit (builtins) strLength;
            mkListcharsOption = k: { description, min ? 1, max ? 1 }: mkVimOptOption k {
              type = lib.types.str;
              apply = x:
                assert (
                  (strLength x >= min && strLength x <= max)
                    || abort ''
                    The number of characters ${x} does not correspond to the boundaries
                    (min: ${tostr min}; max: ${tostr max})
                  ''
                );
                x;
              inherit description;
            };
          in
          (mapAttrs mkListcharsOption {
            eol = {
              description = ''
                Character to show at the end of each line.  When
                omitted, there is no extra character at the end of the
                line.
              '';
            };

            tab = {
              description = ''
                Two or three characters to be used to show a tab.
                The third character is optional.
              '';
              max = 3;
            };

            space = {
              description = ''
                Character to show for a space.  When omitted, spaces are left blank.
              '';
            };

            multispace = {
              description = ''
                One or more characters to use cyclically to show for
                multiple consecutive spaces.  Overrides the "space"
                setting, except for single spaces.
              '';
              max = 99;
            };

            lead = {
              description = ''
                Character to show for leading spaces.  When omitted,
                leading spaces are blank.  Overrides the "space" and
                "multispace" settings for leading spaces.
 
              '';
            };

            leadmultispace = {
              description = ''
                Like the |lcs-multispace| value, but for leading
                spaces only.  Also overrides |lcs-lead| for leading
                multiple spaces.
              '';
              max = 99;
            };

            trail = {
              description = ''
                Character to show for trailing spaces.  When omitted,
                trailing spaces are blank.  Overrides the "space" and
                "multispace" settings for trailing spaces.
              '';
            };

            extends = {
              description = ''
                Character to show in the last column, when 'wrap' is
                off and the line continues beyond the right of the
                screen.
              '';
            };

            precedes = {
              description = ''
                Character to show in the first visible column of the
                physical line, when there is text preceding the
                character visible in the first column.
              '';
            };

            conceal = {
              description = ''
                Character to show in place of concealed text, when
                'conceallevel' is set to 1.  A space when omitted.
              '';
            };

            nbsp = {
              description = ''
                Character to show for a non-breakable space character
                (0xA0 (160 decimal) and U+202F).
              '';
            };
          });
      };
    };
  };

  buffer = with lib; with types; sharedGlobalOrBuffer // {
    autoindent = {
      type = bool;
      default = true;
      description = ''
        Copy indent from current line when starting a new line (typing <CR>
        in Insert mode or when using the "o" or "O" command).  If you do not
        type anything on the new line except <BS> or CTRL-D and then type
        <Esc>, CTRL-O or <CR>, the indent is deleted again.
 
      '';
    };

    binary = {
      type = bool;
      default = false;
      description = ''
        This option should be set before editing a binary file.  You can also
        use the |-b| Vim argument.
      '';
    };

    bomb = {
      type = bool;
      default = false;
      description = ''
        When writing a file and the following conditions are met, a BOM (Byte
        Order Mark) is prepended to the file:
        - this option is on
        - the 'binary' option is off
        - 'fileencoding' is "utf-8", "ucs-2", "ucs-4" or one of the little/big
          endian variants.
 
      '';
    };

    bufhidden = {
      type = (enum [ "" "hide" "unload" "delete" "wipe" ]);
      default = "";
      description = ''
        This option specifies what happens when a buffer is no longer
        displayed in a window
 
      '';
    };

    buflisted = {
      type = bool;
      default = true;
      description = ''
        When this option is set, the buffer shows up in the buffer list.
 
      '';
    };

    buftype = {
      type = (enum [ "" "acwrite" "help" "nofile" "nowrite" "quickfix" "terminal" "prompt" ]);
      default = "";
      description = ''
        This option is used together with 'bufhidden' and 'swapfile' to
        specify special kinds of buffers.
 
      '';
      extraHelp = [ "special-buffers" ];
    };

    cindent = {
      type = bool;
      default = false;
      description = ''
        Enables automatic C program indenting.
 
      '';
    };

    cinkeys = {
      type = str;
      default = "0{,0},0),0],:,0#,!^F,o,O,e";
      description = ''
        A list of keys that, when typed in Insert mode, cause reindenting of
        the current line.
 
      '';
    };

    cinoptions = {
      type = str;
      default = "";
      description = ''
        The 'cinoptions' affect the way 'cindent' reindents lines in a C
        program.
      '';
      extraHelp = [ "cinoptions-values" ];
    };

    cinwords = {
      type = commas;
      default = ''["if" "else" "while" "do" "for" "switch"]'';
      descrpition = ''
        These keywords start an extra indent in the next line when
        'smartindent' or 'cindent' is set.  For 'cindent' this is only done at
        an appropriate place (inside {}).
 
      '';
    };

    cinscopedecls = {
      type = commas;
      default = ''["public" "protected" "private"]'';
      descrpition = ''
        Keywords that are interpreted as a C++ scope declaration by |cino-g|.
        Useful e.g. for working with the Qt framework that defines additional
        scope declarations "signals", "public slots" and "private slots"
 
      '';
    };

    comments = {
      type = commas;
      default = ''
        [
          "s1/*"
          "mb:8"
          "ex:*/"
          "://"
          "b:#"
          ":%"
          ":XCOMM"
          "n:>"
          "fb:-"
        ]
      '';
      description = ''
        list of strs that can start a comment line.
 
      '';
      extraHelp = [ "format-comments" ];
    };

    commentstring = {
      type = str;
      default = "";
      description = ''
        A template for a comment.  The "%s" in the value is replaced with the
        comment text.  Currently only used to add markers for folding, see
        |fold-marker|.
 
      '';
      extraHelp = [ "fold-marker" ];
    };

    complete = {
      type = commas;
      default = ''["." "w" "b" "u" "t"]'';
      description = ''
        This option specifies how keyword completion |ins-completion| works
        when CTRL-P or CTRL-N are used.
 
      '';
      extraHelp = [ "ins-completion" ];
    };

    completefunc = {
      type = str;
      default = "";
      description = ''
        This option specifies a function to be used for Insert mode completion
        with CTRL-X CTRL-U.
 
      '';
      extraHelp = [
        "complete-functions"
        "i_CTRL-X_CTRL-U"
      ];
    };

    copyindent = {
      type = bool;
      default = false;
      description = ''
        Copy the structure of the existing lines indent when autoindenting a
        new line.  Normally the new indent is reconstructed by a series of
        tabs followed by spaces as required (unless |'expandtab'| is enabled,
        in which case only spaces are used).  Enabling this option makes the
        new line copy whatever characters were used for indenting on the
        existing line.
 
      '';
      extraHelp = [
        "expandtab"
        "preverseindent"
      ];
    };

    expandtab = {
      type = bool;
      default = false;
      description = ''
        In Insert mode: Use the appropriate number of spaces to insert a
        <Tab>.  Spaces are used in indents with the '>' and '<' commands and
        when 'autoindent' is on.  To insert a real tab when 'expandtab' is
        on, use CTRL-V<Tab>.  See also |:retab| and |ins-expandtab|.
      '';
    };

    fileencoding = {
      type = str;
      default = "";
      description = ''
        File-content encoding for the current buffer. Conversion is done with
        iconv() or as specified with 'charconvert'.

        When 'fileencoding' is not UTF-8, conversion will be done when
        writing the file.  For reading see below.
        When 'fileencoding' is empty, the file will be saved with UTF-8
        encoding (no conversion when reading or writing a file).
 
      '';
    };

    fileformat = {
      type = (enum [ "dos" "unix" "mac" ]);
      default = ''
        Windows default: "dos",
        Unix default: "unix"
      '';
      description = ''
        This gives the <EOL> of the current buffer, which is used for
        reading/writing the buffer from/to a file:
        - dos	    <CR><NL>
        - unix    <NL>
        - mac	    <CR>
        When "dos" is used, CTRL-Z at the end of a file is ignored.
      '';
    };

    filetype = {
      type = str;
      description = ''
        When this option is set, the FileType autocommand event is triggered.

        Otherwise this option does not always reflect the current file type.
        This option is normally set when the file type is detected.  To enable
        this use the ":filetype on" command. |:filetype|

        When a dot appears in the value then this separates two filetype names.
 
      '';
      extraHelp = [ ":filetype" ];
    };

    fixendofline = {
      type = bool;
      default = true;
      description = ''
        When writing a file and this option is on, <EOL> at the end of file
        will be restored if missing.  Turn this option off if you want to
        preserve the situation from the original file.
        When the 'binary' option is set the value of this option doesn't
        matter.
 
      '';
      extraHelp = [
        "binary"
        "endofline"
        "eol-and-eof"
      ];
    };

    formatexpr = {
      type = str;
      default = "";
      description = ''
        Expression which is evaluated to format a range of lines for the |gq|
        operator or automatic formatting (see 'formatoptions').  When this
        option is empty 'formatprg' is used.
 
      '';
    };

    formatlistpat = {
      type = str;
      default = ''^\s*\d\+[\]:.)}\t ]\s*'';
      description = ''
        A pattern that is used to recognize a list header.  This is used for
        the "n" flag in 'formatoptions'.

        The default recognizes a number, followed by an optional punctuation
 
      '';
      extraHelp = [ "formatoptions" ];
    };

    formatoptions = {
      type = str;
      default = "tcqj";
      description = ''
        This is a sequence of letters which describes how automatic
        formatting is to be done.
 
      '';
      extraHelp = [ "fo-table" ];
    };

    iminsert = {
      type = number;
      default = 0;
      description = ''
        Specifies whether :lmap or an Input Method (IM) is to be used in
        Insert mode.  Valid values:
        - 0   :lmap is off and IM is off
        - 1   :lmap is ON and IM is off
        - 2   :lmap is off and IM is ON
 
      '';
    };

    imsearch = {
      type = number;
      default = -1;
      description = ''
        Specifies whether :lmap or an Input Method (IM) is to be used when
        entering a search pattern.  Valid values:
        - -1  the value of 'iminsert' is used, makes it look like
            'iminsert' is also used when typing a search pattern
        - 0   :lmap is off and IM is off
        - 1   :lmap is ON and IM is off
        - 2   :lmap is off and IM is ON
 
      '';
    };

    includexpr = {
      type = str;
      default = "";
      description = ''
        Expression to be used to transform the str found with the 'include'
        option to a file name.
 
      '';
    };

    indentexpr = {
      type = str;
      default = "";
      description = ''
        Expression which is evaluated to obtain the proper indent for a line.
        It is used when a new line is created, for the |=| operator and
        in Insert mode as specified with the 'indentkeys' option.
 
      '';
    };

    indentkeys = {
      type = str;
      default = "0{,0},0),0],:,0#,!^F,o,O,e";
      description = ''
        A list of keys that, when typed in Insert mode, cause reindenting of
        the current line.
 
      '';
    };

    infercase = {
      type = bool;
      default = false;
      description = ''
        When doing keyword completion in insert mode |ins-completion|, and
        'ignorecase' is also on, the case of the match is adjusted depending
        on the typed text.  If the typed text contains a lowercase letter
        where the match has an upper case letter, the completed part is made
        lowercase.
 
      '';
    };

    iskeyward = {
      type = str;
      default = "@,48-57,_,192-255";
      description = ''
        Keywords are used in searching and recognizing with many commands:
        "w", "*", "[i", etc.  It is also used for "\k" in a |pattern|.
 
      '';
      extraHelp = [ "pattern" ];
    };

    keymap = {
      type = str;
      default = "";
      description = ''
        Name of a keyboard mapping.
 
      '';
      extraHelp = [ "mbyte-keymap" ];
    };

    lisp = {
      type = bool;
      default = false;
      description = ''
        Lisp mode: When <Enter> is typed in insert mode set the indent for
        the next line to Lisp standards (well, sort of).  Also happens with
        "cc" or "S".
 
      '';
    };

    lispoptions = {
      type = (listOf str);
      default = [ ];
      description = ''
        list of items that influence the Lisp indenting when
        enabled with the |'lisp'| option.  Currently only one item is
        supported:

        - expr:1	use 'indentexpr' for Lisp indenting when it is set
        - expr:0	do not use 'indentexpr' for Lisp indenting (default)
      '';
    };
  };
in
mapAttrs (_: mapAttrs mkVimOptOption) {
  inherit global window buffer;
}