chore(build): auto-generate vimdoc

doc/lazy.nvim.txt

@@ -120,9 +120,10 @@ PLUGIN SPEC                                            *lazy.nvim-plugin-spec*
 │**lazy**        │boolean?                                                     │When true, the plugin will only be loaded when needed. Lazy-loaded plugins are automatically loaded when their Lua modules are required, or when one of the lazy-loading handlers triggers                                                     │
 │**enabled**     │boolean? or fun():boolean                                    │When false, or if the function returns false, then this plugin will not be included in the spec                                                                                                                                                │
 │**cond**        │boolean? or fun():boolean                                    │When false, or if the function returns false, then this plugin will not be loaded. Useful to disable some plugins in vscode, or firenvim for example.                                                                                          │
-│**dependencies**│LazySpec[]                                                   │A list of plugin names or plugin specs that should be loaded when the plugin loads. Dependencies are always lazy-loaded unless specified otherwise. When specifying a name, make sure the plugin spec has been defined somewhere else.│
+│**dependencies**│LazySpec[]                                                   │A list of plugin names or plugin specs that should be loaded when the plugin loads. Dependencies are always lazy-loaded unless specified otherwise. When specifying a name, make sure the plugin spec has been defined somewhere else.         │
 │**init**        │fun(LazyPlugin)                                              │init functions are always executed during startup                                                                                                                                                                                              │
-│**config**      │fun(LazyPlugin) or true or table                             │config is executed when the plugin loads. You can also set to true or pass a table, that will be passed to require("plugin").setup(opts)                                                                                              │
+│**config**      │fun(LazyPlugin, opts:table) or true                          │config is executed when the plugin loads. You can also set it to true, to automatically run require("plugin").setup(opts). See also opts.                                                                                                      │
+│**opts**        │table or fun(LazyPlugin, opts:table)                         │opts should be a table (will be merged with parent specs), return a table (replaces parent specs) or should change a table. The table will be passed to the Plugin.config() function. Setting this value will imply Plugin.config()            │
 │**build**       │fun(LazyPlugin) or string or a list of build commands        │build is executed when a plugin is installed or updated. If it’s a string it will be ran as a shell command. When prefixed with : it is a Neovim command. You can also specify a list to executed multiple build commands                    │
 │**branch**      │string?                                                      │Branch of the repository                                                                                                                                                                                                                       │
 │**tag**         │string?                                                      │Tag of the repository                                                                                                                                                                                                                          │
@@ -271,11 +272,11 @@ EXAMPLES ~
         config = true, -- run require("neorg").setup()
       },
     
-      -- or set a custom config:
+      -- or set custom options:
       {
         "nvim-neorg/neorg",
         ft = "norg",
-        config = { foo = "bar" }, -- run require("neorg").setup({foo = "bar"})
+        opts = { foo = "bar" }, -- run require("neorg").setup({foo = "bar"})
       },
     
       {
@@ -724,6 +725,26 @@ For a real-life example, you can check LazyVim
 - lazyvim.plugins <https://github.com/LazyVim/LazyVim/tree/main/lua/lazyvim/plugins> contains all the plugin specs that will be loaded
 
 
+IMPORTING SPECS, `CONFIG` & `OPTS` ~
+
+As part of a spec, you can add `import` statements to import additional plugin
+modules. Both of the `setup()` calls are equivalent:
+
+>lua
+    require("lazy").setup("plugins")
+    
+    -- same as:
+    require("lazy").setup({{import = "plugins"}})
+<
+
+
+When you import specs, you can override them by simply adding a spec for the
+same plugin to your local specs, adding any keys you want to override / merge.
+
+`opts`, `dependencies`, `cmd`, `event`, `ft` and `keys` are always merged with
+the parent spec. Any other property will override the property from the parent
+spec.
+
 MIGRATION GUIDE                                    *lazy.nvim-migration-guide*
 
 PACKER.NVIM <HTTPS://GITHUB.COM/WBTHOMASON/PACKER.NVIM> ~