commit a16b25432e246a35c84a484c3cb385f94998c756 · pyrox.dev/nixpkgs

+2 -2

nixos/modules/config/appstream.nix

···

       6
       6
        
           appstream.enable = mkOption {

     

       7
       7
        
             type = types.bool;

     

       8
       8
        
             default = true;

     

       9
       9
       -
             description = ''

     

       9
       9
       +
             description = lib.mdDoc ''

     

       10
       10
        
               Whether to install files to support the

     

       11
       11
       -
               <link xlink:href="https://www.freedesktop.org/software/appstream/docs/index.html">AppStream metadata specification</link>.

     

       11
       11
       +
               [AppStream metadata specification](https://www.freedesktop.org/software/appstream/docs/index.html).

     

       12
       12
        
             '';

     

       13
       13
        
           };

     

       14
       14
        
         };

+4 -4

nixos/modules/config/fonts/fontdir.nix

···

       30
       30
        
             enable = mkOption {

     

       31
       31
        
               type = types.bool;

     

       32
       32
        
               default = false;

     

       33
       33
       -
               description = ''

     

       33
       33
       +
               description = lib.mdDoc ''

     

       34
       34
        
                 Whether to create a directory with links to all fonts in

     

       35
       35
       -
                 <filename>/run/current-system/sw/share/X11/fonts</filename>.

     

       35
       35
       +
                 {file}`/run/current-system/sw/share/X11/fonts`.

     

       36
       36
        
               '';

     

       37
       37
        
             };

     

       38
       38
        
       

     
···

       40
       40
        
               type = types.bool;

     

       41
       41
        
               default = config.programs.xwayland.enable;

     

       42
       42
        
               defaultText = literalExpression "config.programs.xwayland.enable";

     

       43
       43
       -
               description = ''

     

       43
       43
       +
               description = lib.mdDoc ''

     

       44
       44
        
                 Whether to decompress fonts in

     

       45
       45
       -
                 <filename>/run/current-system/sw/share/X11/fonts</filename>.

     

       45
       45
       +
                 {file}`/run/current-system/sw/share/X11/fonts`.

     

       46
       46
        
               '';

     

       47
       47
        
             };

     

       48
       48

+9 -10

nixos/modules/config/locale.nix

···

       22
       22
        
               default = null;

     

       23
       23
        
               type = timezone;

     

       24
       24
        
               example = "America/New_York";

     

       25
       25
       -
               description = ''

     

       26
       26
       -
                 The time zone used when displaying times and dates. See <link

     

       27
       27
       -
                 xlink:href="https://en.wikipedia.org/wiki/List_of_tz_database_time_zones"/>

     

       25
       25
       +
               description = lib.mdDoc ''

     

       26
       26
       +
                 The time zone used when displaying times and dates. See <https://en.wikipedia.org/wiki/List_of_tz_database_time_zones>

     

       28
       27
        
                 for a comprehensive list of possible values for this setting.

     

       29
       28
        
       

     

       30
       29
        
                 If null, the timezone will default to UTC and can be set imperatively

     
···

       35
       34
        
             hardwareClockInLocalTime = mkOption {

     

       36
       35
        
               default = false;

     

       37
       36
        
               type = types.bool;

     

       38
       38
       -
               description = "If set, keep the hardware clock in local time instead of UTC.";

     

       37
       37
       +
               description = lib.mdDoc "If set, keep the hardware clock in local time instead of UTC.";

     

       39
       38
        
             };

     

       40
       39
        
       

     

       41
       40
        
           };

     
···

       44
       43
        
       

     

       45
       44
        
             latitude = mkOption {

     

       46
       45
        
               type = types.float;

     

       47
       47
       -
               description = ''

     

       46
       46
       +
               description = lib.mdDoc ''

     

       48
       47
        
                 Your current latitude, between

     

       49
       49
       -
                 <literal>-90.0</literal> and <literal>90.0</literal>. Must be provided

     

       48
       48
       +
                 `-90.0` and `90.0`. Must be provided

     

       50
       49
        
                 along with longitude.

     

       51
       50
        
               '';

     

       52
       51
        
             };

     

       53
       52
        
       

     

       54
       53
        
             longitude = mkOption {

     

       55
       54
        
               type = types.float;

     

       56
       56
       -
               description = ''

     

       55
       55
       +
               description = lib.mdDoc ''

     

       57
       56
        
                 Your current longitude, between

     

       58
       58
       -
                 between <literal>-180.0</literal> and <literal>180.0</literal>. Must be

     

       57
       57
       +
                 between `-180.0` and `180.0`. Must be

     

       59
       58
        
                 provided along with latitude.

     

       60
       59
        
               '';

     

       61
       60
        
             };

     
···

       63
       62
        
             provider = mkOption {

     

       64
       63
        
               type = types.enum [ "manual" "geoclue2" ];

     

       65
       64
        
               default = "manual";

     

       66
       66
       -
               description = ''

     

       65
       65
       +
               description = lib.mdDoc ''

     

       67
       66
        
                 The location provider to use for determining your location. If set to

     

       68
       68
       -
                 <literal>manual</literal> you must also provide latitude/longitude.

     

       67
       67
       +
                 `manual` you must also provide latitude/longitude.

     

       69
       68
        
               '';

     

       70
       69
        
             };

     

       71
       70

+12 -12

nixos/modules/config/nsswitch.nix

···

       13
       13
        
             type = types.listOf types.path;

     

       14
       14
        
             internal = true;

     

       15
       15
        
             default = [];

     

       16
       16
       -
             description = ''

     

       16
       16
       +
             description = lib.mdDoc ''

     

       17
       17
        
               Search path for NSS (Name Service Switch) modules.  This allows

     

       18
       18
        
               several DNS resolution methods to be specified via

     

       19
       19
       -
               <filename>/etc/nsswitch.conf</filename>.

     

       19
       19
       +
               {file}`/etc/nsswitch.conf`.

     

       20
       20
        
             '';

     

       21
       21
        
             apply = list:

     

       22
       22
        
               {

     
···

       28
       28
        
           system.nssDatabases = {

     

       29
       29
        
             passwd = mkOption {

     

       30
       30
        
               type = types.listOf types.str;

     

       31
       31
       -
               description = ''

     

       32
       32
       -
                 List of passwd entries to configure in <filename>/etc/nsswitch.conf</filename>.

     

       31
       31
       +
               description = lib.mdDoc ''

     

       32
       32
       +
                 List of passwd entries to configure in {file}`/etc/nsswitch.conf`.

     

       33
       33
        
       

     

       34
       34
        
                 Note that "files" is always prepended while "systemd" is appended if nscd is enabled.

     

       35
       35
        
       

     
···

       40
       40
        
       

     

       41
       41
        
             group = mkOption {

     

       42
       42
        
               type = types.listOf types.str;

     

       43
       43
       -
               description = ''

     

       44
       44
       -
                 List of group entries to configure in <filename>/etc/nsswitch.conf</filename>.

     

       43
       43
       +
               description = lib.mdDoc ''

     

       44
       44
       +
                 List of group entries to configure in {file}`/etc/nsswitch.conf`.

     

       45
       45
        
       

     

       46
       46
        
                 Note that "files" is always prepended while "systemd" is appended if nscd is enabled.

     

       47
       47
        
       

     
···

       52
       52
        
       

     

       53
       53
        
             shadow = mkOption {

     

       54
       54
        
               type = types.listOf types.str;

     

       55
       55
       -
               description = ''

     

       56
       56
       -
                 List of shadow entries to configure in <filename>/etc/nsswitch.conf</filename>.

     

       55
       55
       +
               description = lib.mdDoc ''

     

       56
       56
       +
                 List of shadow entries to configure in {file}`/etc/nsswitch.conf`.

     

       57
       57
        
       

     

       58
       58
        
                 Note that "files" is always prepended.

     

       59
       59
        
       

     
···

       64
       64
        
       

     

       65
       65
        
             hosts = mkOption {

     

       66
       66
        
               type = types.listOf types.str;

     

       67
       67
       -
               description = ''

     

       68
       68
       -
                 List of hosts entries to configure in <filename>/etc/nsswitch.conf</filename>.

     

       67
       67
       +
               description = lib.mdDoc ''

     

       68
       68
       +
                 List of hosts entries to configure in {file}`/etc/nsswitch.conf`.

     

       69
       69
        
       

     

       70
       70
        
                 Note that "files" is always prepended, and "dns" and "myhostname" are always appended.

     

       71
       71
        
       

     
···

       76
       76
        
       

     

       77
       77
        
             services = mkOption {

     

       78
       78
        
               type = types.listOf types.str;

     

       79
       79
       -
               description = ''

     

       80
       80
       -
                 List of services entries to configure in <filename>/etc/nsswitch.conf</filename>.

     

       79
       79
       +
               description = lib.mdDoc ''

     

       80
       80
       +
                 List of services entries to configure in {file}`/etc/nsswitch.conf`.

     

       81
       81
        
       

     

       82
       82
        
                 Note that "files" is always prepended.

     

       83
       83

+13 -13

nixos/modules/config/pulseaudio.nix

···

       89
       89
        
             enable = mkOption {

     

       90
       90
        
               type = types.bool;

     

       91
       91
        
               default = false;

     

       92
       92
       -
               description = ''

     

       92
       92
       +
               description = lib.mdDoc ''

     

       93
       93
        
                 Whether to enable the PulseAudio sound server.

     

       94
       94
        
               '';

     

       95
       95
        
             };

     
···

       97
       97
        
             systemWide = mkOption {

     

       98
       98
        
               type = types.bool;

     

       99
       99
        
               default = false;

     

       100
       100
       -
               description = ''

     

       100
       100
       +
               description = lib.mdDoc ''

     

       101
       101
        
                 If false, a PulseAudio server is launched automatically for

     

       102
       102
        
                 each user that tries to use the sound system. The server runs

     

       103
       103
        
                 with user privileges. If true, one system-wide PulseAudio

     
···

       112
       112
        
             support32Bit = mkOption {

     

       113
       113
        
               type = types.bool;

     

       114
       114
        
               default = false;

     

       115
       115
       -
               description = ''

     

       115
       115
       +
               description = lib.mdDoc ''

     

       116
       116
        
                 Whether to include the 32-bit pulseaudio libraries in the system or not.

     

       117
       117
        
                 This is only useful on 64-bit systems and currently limited to x86_64-linux.

     

       118
       118
        
               '';

     
···

       120
       120
        
       

     

       121
       121
        
             configFile = mkOption {

     

       122
       122
        
               type = types.nullOr types.path;

     

       123
       123
       -
               description = ''

     

       123
       123
       +
               description = lib.mdDoc ''

     

       124
       124
        
                 The path to the default configuration options the PulseAudio server

     

       125
       125
        
                 should use. By default, the "default.pa" configuration

     

       126
       126
        
                 from the PulseAudio distribution is used.

     
···

       130
       130
        
             extraConfig = mkOption {

     

       131
       131
        
               type = types.lines;

     

       132
       132
        
               default = "";

     

       133
       133
       -
               description = ''

     

       134
       134
       -
                 Literal string to append to <literal>configFile</literal>

     

       133
       133
       +
               description = lib.mdDoc ''

     

       134
       134
       +
                 Literal string to append to `configFile`

     

       135
       135
        
                 and the config file generated by the pulseaudio module.

     

       136
       136
        
               '';

     

       137
       137
        
             };

     
···

       139
       139
        
             extraClientConf = mkOption {

     

       140
       140
        
               type = types.lines;

     

       141
       141
        
               default = "";

     

       142
       142
       -
               description = ''

     

       142
       142
       +
               description = lib.mdDoc ''

     

       143
       143
        
                 Extra configuration appended to pulse/client.conf file.

     

       144
       144
        
               '';

     

       145
       145
        
             };

     
···

       151
       151
        
                         else pkgs.pulseaudio;

     

       152
       152
        
               defaultText = literalExpression "pkgs.pulseaudio";

     

       153
       153
        
               example = literalExpression "pkgs.pulseaudioFull";

     

       154
       154
       -
               description = ''

     

       154
       154
       +
               description = lib.mdDoc ''

     

       155
       155
        
                 The PulseAudio derivation to use.  This can be used to enable

     

       156
       156
        
                 features (such as JACK support, Bluetooth) via the

     

       157
       157
       -
                 <literal>pulseaudioFull</literal> package.

     

       157
       157
       +
                 `pulseaudioFull` package.

     

       158
       158
        
               '';

     

       159
       159
        
             };

     

       160
       160
        
       

     
···

       162
       162
        
               type = types.listOf types.package;

     

       163
       163
        
               default = [];

     

       164
       164
        
               example = literalExpression "[ pkgs.pulseaudio-modules-bt ]";

     

       165
       165
       -
               description = ''

     

       165
       165
       +
               description = lib.mdDoc ''

     

       166
       166
        
                 Extra pulseaudio modules to use. This is intended for out-of-tree

     

       167
       167
        
                 pulseaudio modules like extra bluetooth codecs.

     

       168
       168
        
       

     
···

       174
       174
        
               logLevel = mkOption {

     

       175
       175
        
                 type = types.str;

     

       176
       176
        
                 default = "notice";

     

       177
       177
       -
                 description = ''

     

       177
       177
       +
                 description = lib.mdDoc ''

     

       178
       178
        
                   The log level that the system-wide pulseaudio daemon should use,

     

       179
       179
        
                   if activated.

     

       180
       180
        
                 '';

     
···

       183
       183
        
               config = mkOption {

     

       184
       184
        
                 type = types.attrsOf types.unspecified;

     

       185
       185
        
                 default = {};

     

       186
       186
       -
                 description = "Config of the pulse daemon. See <literal>man pulse-daemon.conf</literal>.";

     

       186
       186
       +
                 description = lib.mdDoc "Config of the pulse daemon. See `man pulse-daemon.conf`.";

     

       187
       187
        
                 example = literalExpression ''{ realtime-scheduling = "yes"; }'';

     

       188
       188
        
               };

     

       189
       189
        
             };

     
···

       205
       205
        
                   type = types.listOf types.str;

     

       206
       206
        
                   default = [];

     

       207
       207
        
                   example = literalExpression ''[ "127.0.0.1" "192.168.1.0/24" ]'';

     

       208
       208
       -
                   description = ''

     

       208
       208
       +
                   description = lib.mdDoc ''

     

       209
       209
        
                     A list of IP subnets that are allowed to stream to the server.

     

       210
       210
        
                   '';

     

       211
       211
        
                 };

+3 -3

nixos/modules/config/unix-odbc-drivers.nix

···

       20
       20
        
             type = types.listOf types.package;

     

       21
       21
        
             default = [];

     

       22
       22
        
             example = literalExpression "with pkgs.unixODBCDrivers; [ sqlite psql ]";

     

       23
       23
       -
             description = ''

     

       23
       23
       +
             description = lib.mdDoc ''

     

       24
       24
        
               Specifies Unix ODBC drivers to be registered in

     

       25
       25
       -
               <filename>/etc/odbcinst.ini</filename>.  You may also want to

     

       26
       26
       -
               add <literal>pkgs.unixODBC</literal> to the system path to get

     

       25
       25
       +
               {file}`/etc/odbcinst.ini`.  You may also want to

     

       26
       26
       +
               add `pkgs.unixODBC` to the system path to get

     

       27
       27
        
               a command line client to connect to ODBC databases.

     

       28
       28
        
             '';

     

       29
       29
        
           };

+2 -2

nixos/modules/config/xdg/autostart.nix

···

       10
       10
        
           xdg.autostart.enable = mkOption {

     

       11
       11
        
             type = types.bool;

     

       12
       12
        
             default = true;

     

       13
       13
       -
             description = ''

     

       13
       13
       +
             description = lib.mdDoc ''

     

       14
       14
        
               Whether to install files to support the

     

       15
       15
       -
               <link xlink:href="https://specifications.freedesktop.org/autostart-spec/autostart-spec-latest.html">XDG Autostart specification</link>.

     

       15
       15
       +
               [XDG Autostart specification](https://specifications.freedesktop.org/autostart-spec/autostart-spec-latest.html).

     

       16
       16
        
             '';

     

       17
       17
        
           };

     

       18
       18
        
         };

+2 -2

nixos/modules/config/xdg/icons.nix

···

       10
       10
        
           xdg.icons.enable = mkOption {

     

       11
       11
        
             type = types.bool;

     

       12
       12
        
             default = true;

     

       13
       13
       -
             description = ''

     

       13
       13
       +
             description = lib.mdDoc ''

     

       14
       14
        
               Whether to install files to support the

     

       15
       15
       -
               <link xlink:href="https://specifications.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html">XDG Icon Theme specification</link>.

     

       15
       15
       +
               [XDG Icon Theme specification](https://specifications.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html).

     

       16
       16
        
             '';

     

       17
       17
        
           };

     

       18
       18
        
         };

+2 -2

nixos/modules/config/xdg/menus.nix

···

       10
       10
        
           xdg.menus.enable = mkOption {

     

       11
       11
        
             type = types.bool;

     

       12
       12
        
             default = true;

     

       13
       13
       -
             description = ''

     

       13
       13
       +
             description = lib.mdDoc ''

     

       14
       14
        
               Whether to install files to support the

     

       15
       15
       -
               <link xlink:href="https://specifications.freedesktop.org/menu-spec/menu-spec-latest.html">XDG Desktop Menu specification</link>.

     

       15
       15
       +
               [XDG Desktop Menu specification](https://specifications.freedesktop.org/menu-spec/menu-spec-latest.html).

     

       16
       16
        
             '';

     

       17
       17
        
           };

     

       18
       18
        
         };

+2 -2

nixos/modules/config/xdg/sounds.nix

···

       10
       10
        
           xdg.sounds.enable = mkOption {

     

       11
       11
        
             type = types.bool;

     

       12
       12
        
             default = true;

     

       13
       13
       -
             description = ''

     

       13
       13
       +
             description = lib.mdDoc ''

     

       14
       14
        
               Whether to install files to support the

     

       15
       15
       -
               <link xlink:href="https://www.freedesktop.org/wiki/Specifications/sound-theme-spec/">XDG Sound Theme specification</link>.

     

       15
       15
       +
               [XDG Sound Theme specification](https://www.freedesktop.org/wiki/Specifications/sound-theme-spec/).

     

       16
       16
        
             '';

     

       17
       17
        
           };

     

       18
       18
        
         };

+7 -7

nixos/modules/hardware/cpu/intel-sgx.nix

···

       6
       6
        
       in

     

       7
       7
        
       {

     

       8
       8
        
         options.hardware.cpu.intel.sgx.enableDcapCompat = mkOption {

     

       9
       9
       -
           description = ''

     

       9
       9
       +
           description = lib.mdDoc ''

     

       10
       10
        
             Whether to enable backward compatibility for SGX software build for the

     

       11
       11
        
             out-of-tree Intel SGX DCAP driver.

     

       12
       12
        
       

     

       13
       13
       -
             Creates symbolic links for the SGX devices <literal>/dev/sgx_enclave</literal>

     

       14
       14
       -
             and <literal>/dev/sgx_provision</literal> to make them available as

     

       15
       15
       -
             <literal>/dev/sgx/enclave</literal>  and <literal>/dev/sgx/provision</literal>,

     

       13
       13
       +
             Creates symbolic links for the SGX devices `/dev/sgx_enclave`

     

       14
       14
       +
             and `/dev/sgx_provision` to make them available as

     

       15
       15
       +
             `/dev/sgx/enclave`  and `/dev/sgx/provision`,

     

       16
       16
        
             respectively.

     

       17
       17
        
           '';

     

       18
       18
        
           type = types.bool;

     
···

       22
       22
        
         options.hardware.cpu.intel.sgx.provision = {

     

       23
       23
        
           enable = mkEnableOption "access to the Intel SGX provisioning device";

     

       24
       24
        
           user = mkOption {

     

       25
       25
       -
             description = "Owner to assign to the SGX provisioning device.";

     

       25
       25
       +
             description = lib.mdDoc "Owner to assign to the SGX provisioning device.";

     

       26
       26
        
             type = types.str;

     

       27
       27
        
             default = "root";

     

       28
       28
        
           };

     

       29
       29
        
           group = mkOption {

     

       30
       30
       -
             description = "Group to assign to the SGX provisioning device.";

     

       30
       30
       +
             description = lib.mdDoc "Group to assign to the SGX provisioning device.";

     

       31
       31
        
             type = types.str;

     

       32
       32
        
             default = defaultPrvGroup;

     

       33
       33
        
           };

     

       34
       34
        
           mode = mkOption {

     

       35
       35
       -
             description = "Mode to set for the SGX provisioning device.";

     

       35
       35
       +
             description = lib.mdDoc "Mode to set for the SGX provisioning device.";

     

       36
       36
        
             type = types.str;

     

       37
       37
        
             default = "0660";

     

       38
       38
        
           };

+2 -2

nixos/modules/hardware/ksm.nix

···

       15
       15
        
           sleep = mkOption {

     

       16
       16
        
             type = types.nullOr types.int;

     

       17
       17
        
             default = null;

     

       18
       18
       -
             description = ''

     

       18
       18
       +
             description = lib.mdDoc ''

     

       19
       19
        
               How many milliseconds ksmd should sleep between scans.

     

       20
       20
       -
               Setting it to <literal>null</literal> uses the kernel's default time.

     

       20
       20
       +
               Setting it to `null` uses the kernel's default time.

     

       21
       21
        
             '';

     

       22
       22
        
           };

     

       23
       23
        
         };

+2 -2

nixos/modules/i18n/input-method/fcitx.nix

···

       22
       22
        
                 let

     

       23
       23
        
                   enginesDrv = filterAttrs (const isDerivation) pkgs.fcitx-engines;

     

       24
       24
        
                   engines = concatStringsSep ", "

     

       25
       25
       -
                     (map (name: "<literal>${name}</literal>") (attrNames enginesDrv));

     

       25
       25
       +
                     (map (name: "`${name}`") (attrNames enginesDrv));

     

       26
       26
        
                 in

     

       27
       27
       -
                   "Enabled Fcitx engines. Available engines are: ${engines}.";

     

       27
       27
       +
                   lib.mdDoc "Enabled Fcitx engines. Available engines are: ${engines}.";

     

       28
       28
        
             };

     

       29
       29
        
           };

     

       30
       30

+3 -3

nixos/modules/i18n/input-method/ibus.nix

···

       43
       43
        
                 let

     

       44
       44
        
                   enginesDrv = filterAttrs (const isDerivation) pkgs.ibus-engines;

     

       45
       45
        
                   engines = concatStringsSep ", "

     

       46
       46
       -
                     (map (name: "<literal>${name}</literal>") (attrNames enginesDrv));

     

       46
       46
       +
                     (map (name: "`${name}`") (attrNames enginesDrv));

     

       47
       47
        
                 in

     

       48
       48
       -
                   "Enabled IBus engines. Available engines are: ${engines}.";

     

       48
       48
       +
                   lib.mdDoc "Enabled IBus engines. Available engines are: ${engines}.";

     

       49
       49
        
             };

     

       50
       50
        
             panel = mkOption {

     

       51
       51
        
               type = with types; nullOr path;

     

       52
       52
        
               default = null;

     

       53
       53
        
               example = literalExpression ''"''${pkgs.plasma5Packages.plasma-desktop}/lib/libexec/kimpanel-ibus-panel"'';

     

       54
       54
       -
               description = "Replace the IBus panel with another panel.";

     

       54
       54
       +
               description = lib.mdDoc "Replace the IBus panel with another panel.";

     

       55
       55
        
             };

     

       56
       56
        
           };

     

       57
       57
        
         };

+9 -9

nixos/modules/installer/tools/tools.nix

···

       75
       75
        
           configuration = mkOption {

     

       76
       76
        
             internal = true;

     

       77
       77
        
             type = types.str;

     

       78
       78
       -
             description = ''

     

       79
       79
       -
               The NixOS module that <literal>nixos-generate-config</literal>

     

       80
       80
       -
               saves to <literal>/etc/nixos/configuration.nix</literal>.

     

       78
       78
       +
             description = lib.mdDoc ''

     

       79
       79
       +
               The NixOS module that `nixos-generate-config`

     

       80
       80
       +
               saves to `/etc/nixos/configuration.nix`.

     

       81
       81
        
       

     

       82
       82
        
               This is an internal option. No backward compatibility is guaranteed.

     

       83
       83
        
               Use at your own risk!

     

       84
       84
        
       

     

       85
       85
        
               Note that this string gets spliced into a Perl script. The perl

     

       86
       86
       -
               variable <literal>$bootLoaderConfig</literal> can be used to

     

       86
       86
       +
               variable `$bootLoaderConfig` can be used to

     

       87
       87
        
               splice in the boot loader configuration.

     

       88
       88
        
             '';

     

       89
       89
        
           };

     
···

       92
       92
        
             internal = true;

     

       93
       93
        
             type = types.listOf types.lines;

     

       94
       94
        
             default = [];

     

       95
       95
       -
             description = ''

     

       96
       96
       -
               Text to preseed the desktop configuration that <literal>nixos-generate-config</literal>

     

       97
       97
       -
               saves to <literal>/etc/nixos/configuration.nix</literal>.

     

       95
       95
       +
             description = lib.mdDoc ''

     

       96
       96
       +
               Text to preseed the desktop configuration that `nixos-generate-config`

     

       97
       97
       +
               saves to `/etc/nixos/configuration.nix`.

     

       98
       98
        
       

     

       99
       99
        
               This is an internal option. No backward compatibility is guaranteed.

     

       100
       100
        
               Use at your own risk!

     

       101
       101
        
       

     

       102
       102
        
               Note that this string gets spliced into a Perl script. The perl

     

       103
       103
       -
               variable <literal>$bootLoaderConfig</literal> can be used to

     

       103
       103
       +
               variable `$bootLoaderConfig` can be used to

     

       104
       104
        
               splice in the boot loader configuration.

     

       105
       105
        
             '';

     

       106
       106
        
           };

     
···

       110
       110
        
           internal = true;

     

       111
       111
        
           type = types.bool;

     

       112
       112
        
           default = false;

     

       113
       113
       -
           description = ''

     

       113
       113
       +
           description = lib.mdDoc ''

     

       114
       114
        
             Disable nixos-rebuild, nixos-generate-config, nixos-installer

     

       115
       115
        
             and other NixOS tools. This is useful to shrink embedded,

     

       116
       116
        
             read-only systems which are not expected to be rebuild or

+2 -2

nixos/modules/misc/man-db.nix

···

       36
       36
        
               type = lib.types.package;

     

       37
       37
        
               default = pkgs.man-db;

     

       38
       38
        
               defaultText = lib.literalExpression "pkgs.man-db";

     

       39
       39
       -
               description = ''

     

       40
       40
       -
                 The <literal>man-db</literal> derivation to use. Useful to override

     

       39
       39
       +
               description = lib.mdDoc ''

     

       40
       40
       +
                 The `man-db` derivation to use. Useful to override

     

       41
       41
        
                 configuration options used for the package.

     

       42
       42
        
               '';

     

       43
       43
        
             };

+4 -4

nixos/modules/misc/mandoc.nix

···

       16
       16
        
               type = with lib.types; listOf str;

     

       17
       17
        
               default = [ "share/man" ];

     

       18
       18
        
               example = lib.literalExpression "[ \"share/man\" \"share/man/fr\" ]";

     

       19
       19
       -
               description = ''

     

       19
       19
       +
               description = lib.mdDoc ''

     

       20
       20
        
                 Change the manpath, i. e. the directories where

     

       21
       21
       -
                 <citerefentry><refentrytitle>man</refentrytitle><manvolnum>1</manvolnum></citerefentry>

     

       21
       21
       +
                 {manpage}`man(1)`

     

       22
       22
        
                 looks for section-specific directories of man pages.

     

       23
       23
        
                 You only need to change this setting if you want extra man pages

     

       24
       24
        
                 (e. g. in non-english languages). All values must be strings that

     
···

       31
       31
        
               type = lib.types.package;

     

       32
       32
        
               default = pkgs.mandoc;

     

       33
       33
        
               defaultText = lib.literalExpression "pkgs.mandoc";

     

       34
       34
       -
               description = ''

     

       35
       35
       -
                 The <literal>mandoc</literal> derivation to use. Useful to override

     

       34
       34
       +
               description = lib.mdDoc ''

     

       35
       35
       +
                 The `mandoc` derivation to use. Useful to override

     

       36
       36
        
                 configuration options used for the package.

     

       37
       37
        
               '';

     

       38
       38
        
             };

+8 -8

nixos/modules/misc/version.nix

···

       49
       49
        
           nixos.version = mkOption {

     

       50
       50
        
             internal = true;

     

       51
       51
        
             type = types.str;

     

       52
       52
       -
             description = "The full NixOS version (e.g. <literal>16.03.1160.f2d4ee1</literal>).";

     

       52
       52
       +
             description = lib.mdDoc "The full NixOS version (e.g. `16.03.1160.f2d4ee1`).";

     

       53
       53
        
           };

     

       54
       54
        
       

     

       55
       55
        
           nixos.release = mkOption {

     

       56
       56
        
             readOnly = true;

     

       57
       57
        
             type = types.str;

     

       58
       58
        
             default = trivial.release;

     

       59
       59
       -
             description = "The NixOS release (e.g. <literal>16.03</literal>).";

     

       59
       59
       +
             description = lib.mdDoc "The NixOS release (e.g. `16.03`).";

     

       60
       60
        
           };

     

       61
       61
        
       

     

       62
       62
        
           nixos.versionSuffix = mkOption {

     

       63
       63
        
             internal = true;

     

       64
       64
        
             type = types.str;

     

       65
       65
        
             default = trivial.versionSuffix;

     

       66
       66
       -
             description = "The NixOS version suffix (e.g. <literal>1160.f2d4ee1</literal>).";

     

       66
       66
       +
             description = lib.mdDoc "The NixOS version suffix (e.g. `1160.f2d4ee1`).";

     

       67
       67
        
           };

     

       68
       68
        
       

     

       69
       69
        
           nixos.revision = mkOption {

     

       70
       70
        
             internal = true;

     

       71
       71
        
             type = types.nullOr types.str;

     

       72
       72
        
             default = trivial.revisionWithDefault null;

     

       73
       73
       -
             description = "The Git revision from which this NixOS configuration was built.";

     

       73
       73
       +
             description = lib.mdDoc "The Git revision from which this NixOS configuration was built.";

     

       74
       74
        
           };

     

       75
       75
        
       

     

       76
       76
        
           nixos.codeName = mkOption {

     

       77
       77
        
             readOnly = true;

     

       78
       78
        
             type = types.str;

     

       79
       79
        
             default = trivial.codeName;

     

       80
       80
       -
             description = "The NixOS release code name (e.g. <literal>Emu</literal>).";

     

       80
       80
       +
             description = lib.mdDoc "The NixOS release code name (e.g. `Emu`).";

     

       81
       81
        
           };

     

       82
       82
        
       

     

       83
       83
        
           stateVersion = mkOption {

     

       84
       84
        
             type = types.str;

     

       85
       85
        
             default = cfg.release;

     

       86
       86
        
             defaultText = literalExpression "config.${opt.release}";

     

       87
       87
       -
             description = ''

     

       87
       87
       +
             description = lib.mdDoc ''

     

       88
       88
        
               Every once in a while, a new NixOS release may change

     

       89
       89
        
               configuration defaults in a way incompatible with stateful

     

       90
       90
        
               data. For instance, if the default version of PostgreSQL

     
···

       108
       108
        
             internal = true;

     

       109
       109
        
             type = types.str;

     

       110
       110
        
             default = "https://nixos.org/channels/nixos-unstable";

     

       111
       111
       -
             description = "Default NixOS channel to which the root user is subscribed.";

     

       111
       111
       +
             description = lib.mdDoc "Default NixOS channel to which the root user is subscribed.";

     

       112
       112
        
           };

     

       113
       113
        
       

     

       114
       114
        
           configurationRevision = mkOption {

     

       115
       115
        
             type = types.nullOr types.str;

     

       116
       116
        
             default = null;

     

       117
       117
       -
             description = "The Git revision of the top-level flake from which this configuration was built.";

     

       117
       117
       +
             description = lib.mdDoc "The Git revision of the top-level flake from which this configuration was built.";

     

       118
       118
        
           };

     

       119
       119
        
       

     

       120
       120
        
         };

+10 -10

nixos/modules/programs/atop.nix

···

       20
       20
        
               type = types.package;

     

       21
       21
        
               default = pkgs.atop;

     

       22
       22
        
               defaultText = literalExpression "pkgs.atop";

     

       23
       23
       -
               description = ''

     

       23
       23
       +
               description = lib.mdDoc ''

     

       24
       24
        
                 Which package to use for Atop.

     

       25
       25
        
               '';

     

       26
       26
        
             };

     
···

       29
       29
        
               enable = mkOption {

     

       30
       30
        
                 type = types.bool;

     

       31
       31
        
                 default = false;

     

       32
       32
       -
                 description = ''

     

       32
       32
       +
                 description = lib.mdDoc ''

     

       33
       33
        
                   Whether to install and enable the netatop kernel module.

     

       34
       34
        
                   Note: this sets the kernel taint flag "O" for loading out-of-tree modules.

     

       35
       35
        
                 '';

     
···

       38
       38
        
                 type = types.package;

     

       39
       39
        
                 default = config.boot.kernelPackages.netatop;

     

       40
       40
        
                 defaultText = literalExpression "config.boot.kernelPackages.netatop";

     

       41
       41
       -
                 description = ''

     

       41
       41
       +
                 description = lib.mdDoc ''

     

       42
       42
        
                   Which package to use for netatop.

     

       43
       43
        
                 '';

     

       44
       44
        
               };

     
···

       47
       47
        
             atopgpu.enable = mkOption {

     

       48
       48
        
               type = types.bool;

     

       49
       49
        
               default = false;

     

       50
       50
       -
               description = ''

     

       50
       50
       +
               description = lib.mdDoc ''

     

       51
       51
        
                 Whether to install and enable the atopgpud daemon to get information about

     

       52
       52
        
                 NVIDIA gpus.

     

       53
       53
        
               '';

     
···

       56
       56
        
             setuidWrapper.enable = mkOption {

     

       57
       57
        
               type = types.bool;

     

       58
       58
        
               default = false;

     

       59
       59
       -
               description = ''

     

       59
       59
       +
               description = lib.mdDoc ''

     

       60
       60
        
                 Whether to install a setuid wrapper for Atop. This is required to use some of

     

       61
       61
        
                 the features as non-root user (e.g.: ipc information, netatop, atopgpu).

     

       62
       62
        
                 Atop tries to drop the root privileges shortly after starting.

     
···

       66
       66
        
             atopService.enable = mkOption {

     

       67
       67
        
               type = types.bool;

     

       68
       68
        
               default = true;

     

       69
       69
       -
               description = ''

     

       69
       69
       +
               description = lib.mdDoc ''

     

       70
       70
        
                 Whether to enable the atop service responsible for storing statistics for

     

       71
       71
        
                 long-term analysis.

     

       72
       72
        
               '';

     
···

       74
       74
        
             atopRotateTimer.enable = mkOption {

     

       75
       75
        
               type = types.bool;

     

       76
       76
        
               default = true;

     

       77
       77
       -
               description = ''

     

       77
       77
       +
               description = lib.mdDoc ''

     

       78
       78
        
                 Whether to enable the atop-rotate timer, which restarts the atop service

     

       79
       79
        
                 daily to make sure the data files are rotate.

     

       80
       80
        
               '';

     
···

       82
       82
        
             atopacctService.enable = mkOption {

     

       83
       83
        
               type = types.bool;

     

       84
       84
        
               default = true;

     

       85
       85
       -
               description = ''

     

       85
       85
       +
               description = lib.mdDoc ''

     

       86
       86
        
                 Whether to enable the atopacct service which manages process accounting.

     

       87
       87
        
                 This allows Atop to gather data about processes that disappeared in between

     

       88
       88
        
                 two refresh intervals.

     
···

       95
       95
        
                 flags = "a1f";

     

       96
       96
        
                 interval = 5;

     

       97
       97
        
               };

     

       98
       98
       -
               description = ''

     

       99
       99
       -
                 Parameters to be written to <filename>/etc/atoprc</filename>.

     

       98
       98
       +
               description = lib.mdDoc ''

     

       99
       99
       +
                 Parameters to be written to {file}`/etc/atoprc`.

     

       100
       100
        
               '';

     

       101
       101
        
             };

     

       102
       102
        
           };

+10 -10

nixos/modules/programs/bash/bash.nix

···

       30
       30
        
             /*

     

       31
       31
        
             enable = mkOption {

     

       32
       32
        
               default = true;

     

       33
       33
       -
               description = ''

     

       33
       33
       +
               description = lib.mdDoc ''

     

       34
       34
        
                 Whenever to configure Bash as an interactive shell.

     

       35
       35
        
                 Note that this tries to make Bash the default

     

       36
       36
       -
                 <option>users.defaultUserShell</option>,

     

       36
       36
       +
                 {option}`users.defaultUserShell`,

     

       37
       37
        
                 which in turn means that you might need to explicitly

     

       38
       38
        
                 set this variable if you have another shell configured

     

       39
       39
        
                 with NixOS.

     
···

       44
       44
        
       

     

       45
       45
        
             shellAliases = mkOption {

     

       46
       46
        
               default = {};

     

       47
       47
       -
               description = ''

     

       48
       48
       -
                 Set of aliases for bash shell, which overrides <option>environment.shellAliases</option>.

     

       49
       49
       -
                 See <option>environment.shellAliases</option> for an option format description.

     

       47
       47
       +
               description = lib.mdDoc ''

     

       48
       48
       +
                 Set of aliases for bash shell, which overrides {option}`environment.shellAliases`.

     

       49
       49
       +
                 See {option}`environment.shellAliases` for an option format description.

     

       50
       50
        
               '';

     

       51
       51
        
               type = with types; attrsOf (nullOr (either str path));

     

       52
       52
        
             };

     

       53
       53
        
       

     

       54
       54
        
             shellInit = mkOption {

     

       55
       55
        
               default = "";

     

       56
       56
       -
               description = ''

     

       56
       56
       +
               description = lib.mdDoc ''

     

       57
       57
        
                 Shell script code called during bash shell initialisation.

     

       58
       58
        
               '';

     

       59
       59
        
               type = types.lines;

     
···

       61
       61
        
       

     

       62
       62
        
             loginShellInit = mkOption {

     

       63
       63
        
               default = "";

     

       64
       64
       -
               description = ''

     

       64
       64
       +
               description = lib.mdDoc ''

     

       65
       65
        
                 Shell script code called during login bash shell initialisation.

     

       66
       66
        
               '';

     

       67
       67
        
               type = types.lines;

     
···

       69
       69
        
       

     

       70
       70
        
             interactiveShellInit = mkOption {

     

       71
       71
        
               default = "";

     

       72
       72
       -
               description = ''

     

       72
       72
       +
               description = lib.mdDoc ''

     

       73
       73
        
                 Shell script code called during interactive bash shell initialisation.

     

       74
       74
        
               '';

     

       75
       75
        
               type = types.lines;

     
···

       92
       92
        
                   fi

     

       93
       93
        
                 fi

     

       94
       94
        
               '';

     

       95
       95
       -
               description = ''

     

       95
       95
       +
               description = lib.mdDoc ''

     

       96
       96
        
                 Shell script code used to initialise the bash prompt.

     

       97
       97
        
               '';

     

       98
       98
        
               type = types.lines;

     
···

       100
       100
        
       

     

       101
       101
        
             promptPluginInit = mkOption {

     

       102
       102
        
               default = "";

     

       103
       103
       -
               description = ''

     

       103
       103
       +
               description = lib.mdDoc ''

     

       104
       104
        
                 Shell script code used to initialise bash prompt plugins.

     

       105
       105
        
               '';

     

       106
       106
        
               type = types.lines;

+2 -2

nixos/modules/programs/dconf.nix

···

       33
       33
        
             profiles = mkOption {

     

       34
       34
        
               type = types.attrsOf types.path;

     

       35
       35
        
               default = {};

     

       36
       36
       -
               description = "Set of dconf profile files, installed at <filename>/etc/dconf/profiles/<replaceable>name</replaceable></filename>.";

     

       36
       36
       +
               description = lib.mdDoc "Set of dconf profile files, installed at {file}`/etc/dconf/profiles/«name»`.";

     

       37
       37
        
               internal = true;

     

       38
       38
        
             };

     

       39
       39
        
       

     

       40
       40
        
             packages = mkOption {

     

       41
       41
        
               type = types.listOf types.package;

     

       42
       42
        
               default = [];

     

       43
       43
       -
               description = "A list of packages which provide dconf profiles and databases in <filename>/etc/dconf</filename>.";

     

       43
       43
       +
               description = lib.mdDoc "A list of packages which provide dconf profiles and databases in {file}`/etc/dconf`.";

     

       44
       44
        
             };

     

       45
       45
        
           };

     

       46
       46
        
         };

+15 -15

nixos/modules/programs/fish.nix

···

       49
       49
        
       

     

       50
       50
        
             enable = mkOption {

     

       51
       51
        
               default = false;

     

       52
       52
       -
               description = ''

     

       52
       52
       +
               description = lib.mdDoc ''

     

       53
       53
        
                 Whether to configure fish as an interactive shell.

     

       54
       54
        
               '';

     

       55
       55
        
               type = types.bool;

     
···

       58
       58
        
             useBabelfish = mkOption {

     

       59
       59
        
               type = types.bool;

     

       60
       60
        
               default = false;

     

       61
       61
       -
               description = ''

     

       62
       62
       -
                 If enabled, the configured environment will be translated to native fish using <link xlink:href="https://github.com/bouk/babelfish">babelfish</link>.

     

       63
       63
       -
                 Otherwise, <link xlink:href="https://github.com/oh-my-fish/plugin-foreign-env">foreign-env</link> will be used.

     

       61
       61
       +
               description = lib.mdDoc ''

     

       62
       62
       +
                 If enabled, the configured environment will be translated to native fish using [babelfish](https://github.com/bouk/babelfish).

     

       63
       63
       +
                 Otherwise, [foreign-env](https://github.com/oh-my-fish/plugin-foreign-env) will be used.

     

       64
       64
        
               '';

     

       65
       65
        
             };

     

       66
       66
        
       

     

       67
       67
        
             vendor.config.enable = mkOption {

     

       68
       68
        
               type = types.bool;

     

       69
       69
        
               default = true;

     

       70
       70
       -
               description = ''

     

       70
       70
       +
               description = lib.mdDoc ''

     

       71
       71
        
                 Whether fish should source configuration snippets provided by other packages.

     

       72
       72
        
               '';

     

       73
       73
        
             };

     
···

       75
       75
        
             vendor.completions.enable = mkOption {

     

       76
       76
        
               type = types.bool;

     

       77
       77
        
               default = true;

     

       78
       78
       -
               description = ''

     

       78
       78
       +
               description = lib.mdDoc ''

     

       79
       79
        
                 Whether fish should use completion files provided by other packages.

     

       80
       80
        
               '';

     

       81
       81
        
             };

     
···

       83
       83
        
             vendor.functions.enable = mkOption {

     

       84
       84
        
               type = types.bool;

     

       85
       85
        
               default = true;

     

       86
       86
       -
               description = ''

     

       86
       86
       +
               description = lib.mdDoc ''

     

       87
       87
        
                 Whether fish should autoload fish functions provided by other packages.

     

       88
       88
        
               '';

     

       89
       89
        
             };

     
···

       94
       94
        
                 gco = "git checkout";

     

       95
       95
        
                 npu = "nix-prefetch-url";

     

       96
       96
        
               };

     

       97
       97
       -
               description = ''

     

       97
       97
       +
               description = lib.mdDoc ''

     

       98
       98
        
                 Set of fish abbreviations.

     

       99
       99
        
               '';

     

       100
       100
        
               type = with types; attrsOf str;

     
···

       102
       102
        
       

     

       103
       103
        
             shellAliases = mkOption {

     

       104
       104
        
               default = {};

     

       105
       105
       -
               description = ''

     

       106
       106
       -
                 Set of aliases for fish shell, which overrides <option>environment.shellAliases</option>.

     

       107
       107
       -
                 See <option>environment.shellAliases</option> for an option format description.

     

       105
       105
       +
               description = lib.mdDoc ''

     

       106
       106
       +
                 Set of aliases for fish shell, which overrides {option}`environment.shellAliases`.

     

       107
       107
       +
                 See {option}`environment.shellAliases` for an option format description.

     

       108
       108
        
               '';

     

       109
       109
        
               type = with types; attrsOf (nullOr (either str path));

     

       110
       110
        
             };

     

       111
       111
        
       

     

       112
       112
        
             shellInit = mkOption {

     

       113
       113
        
               default = "";

     

       114
       114
       -
               description = ''

     

       114
       114
       +
               description = lib.mdDoc ''

     

       115
       115
        
                 Shell script code called during fish shell initialisation.

     

       116
       116
        
               '';

     

       117
       117
        
               type = types.lines;

     
···

       119
       119
        
       

     

       120
       120
        
             loginShellInit = mkOption {

     

       121
       121
        
               default = "";

     

       122
       122
       -
               description = ''

     

       122
       122
       +
               description = lib.mdDoc ''

     

       123
       123
        
                 Shell script code called during fish login shell initialisation.

     

       124
       124
        
               '';

     

       125
       125
        
               type = types.lines;

     
···

       127
       127
        
       

     

       128
       128
        
             interactiveShellInit = mkOption {

     

       129
       129
        
               default = "";

     

       130
       130
       -
               description = ''

     

       130
       130
       +
               description = lib.mdDoc ''

     

       131
       131
        
                 Shell script code called during interactive fish shell initialisation.

     

       132
       132
        
               '';

     

       133
       133
        
               type = types.lines;

     
···

       135
       135
        
       

     

       136
       136
        
             promptInit = mkOption {

     

       137
       137
        
               default = "";

     

       138
       138
       -
               description = ''

     

       138
       138
       +
               description = lib.mdDoc ''

     

       139
       139
        
                 Shell script code used to initialise fish prompt.

     

       140
       140
        
               '';

     

       141
       141
        
               type = types.lines;

+10 -10

nixos/modules/programs/less.nix

···

       41
       41
        
               type = types.nullOr types.path;

     

       42
       42
        
               default = null;

     

       43
       43
        
               example = literalExpression ''"''${pkgs.my-configs}/lesskey"'';

     

       44
       44
       -
               description = ''

     

       44
       44
       +
               description = lib.mdDoc ''

     

       45
       45
        
                 Path to lesskey configuration file.

     

       46
       46
        
       

     

       47
       47
       -
                 <option>configFile</option> takes precedence over <option>commands</option>,

     

       48
       48
       -
                 <option>clearDefaultCommands</option>, <option>lineEditingKeys</option>, and

     

       49
       49
       -
                 <option>envVariables</option>.

     

       47
       47
       +
                 {option}`configFile` takes precedence over {option}`commands`,

     

       48
       48
       +
                 {option}`clearDefaultCommands`, {option}`lineEditingKeys`, and

     

       49
       49
       +
                 {option}`envVariables`.

     

       50
       50
        
               '';

     

       51
       51
        
             };

     

       52
       52
        
       

     
···

       57
       57
        
                 h = "noaction 5\\e(";

     

       58
       58
        
                 l = "noaction 5\\e)";

     

       59
       59
        
               };

     

       60
       60
       -
               description = "Defines new command keys.";

     

       60
       60
       +
               description = lib.mdDoc "Defines new command keys.";

     

       61
       61
        
             };

     

       62
       62
        
       

     

       63
       63
        
             clearDefaultCommands = mkOption {

     

       64
       64
        
               type = types.bool;

     

       65
       65
        
               default = false;

     

       66
       66
       -
               description = ''

     

       66
       66
       +
               description = lib.mdDoc ''

     

       67
       67
        
                 Clear all default commands.

     

       68
       68
        
                 You should remember to set the quit key.

     

       69
       69
        
                 Otherwise you will not be able to leave less without killing it.

     
···

       76
       76
        
               example = {

     

       77
       77
        
                 e = "abort";

     

       78
       78
        
               };

     

       79
       79
       -
               description = "Defines new line-editing keys.";

     

       79
       79
       +
               description = lib.mdDoc "Defines new line-editing keys.";

     

       80
       80
        
             };

     

       81
       81
        
       

     

       82
       82
        
             envVariables = mkOption {

     
···

       87
       87
        
               example = {

     

       88
       88
        
                 LESS = "--quit-if-one-screen";

     

       89
       89
        
               };

     

       90
       90
       -
               description = "Defines environment variables.";

     

       90
       90
       +
               description = lib.mdDoc "Defines environment variables.";

     

       91
       91
        
             };

     

       92
       92
        
       

     

       93
       93
        
             lessopen = mkOption {

     

       94
       94
        
               type = types.nullOr types.str;

     

       95
       95
        
               default = "|${pkgs.lesspipe}/bin/lesspipe.sh %s";

     

       96
       96
        
               defaultText = literalExpression ''"|''${pkgs.lesspipe}/bin/lesspipe.sh %s"'';

     

       97
       97
       -
               description = ''

     

       97
       97
       +
               description = lib.mdDoc ''

     

       98
       98
        
                 Before less opens a file, it first gives your input preprocessor a chance to modify the way the contents of the file are displayed.

     

       99
       99
        
               '';

     

       100
       100
        
             };

     
···

       102
       102
        
             lessclose = mkOption {

     

       103
       103
        
               type = types.nullOr types.str;

     

       104
       104
        
               default = null;

     

       105
       105
       -
               description = ''

     

       105
       105
       +
               description = lib.mdDoc ''

     

       106
       106
        
                 When less closes a file opened in such a way, it will call another program, called the input postprocessor, which may  perform  any  desired  clean-up  action (such  as deleting the replacement file created by LESSOPEN).

     

       107
       107
        
               '';

     

       108
       108
        
             };

+3 -3

nixos/modules/programs/nano.nix

···

       14
       14
        
             nanorc = lib.mkOption {

     

       15
       15
        
               type = lib.types.lines;

     

       16
       16
        
               default = "";

     

       17
       17
       -
               description = ''

     

       17
       17
       +
               description = lib.mdDoc ''

     

       18
       18
        
                 The system-wide nano configuration.

     

       19
       19
       -
                 See <citerefentry><refentrytitle>nanorc</refentrytitle><manvolnum>5</manvolnum></citerefentry>.

     

       19
       19
       +
                 See {manpage}`nanorc(5)`.

     

       20
       20
        
               '';

     

       21
       21
        
               example = ''

     

       22
       22
        
                 set nowrap

     
···

       27
       27
        
             syntaxHighlight = lib.mkOption {

     

       28
       28
        
               type = lib.types.bool;

     

       29
       29
        
               default = true;

     

       30
       30
       -
               description = "Whether to enable syntax highlight for various languages.";

     

       30
       30
       +
               description = lib.mdDoc "Whether to enable syntax highlight for various languages.";

     

       31
       31
        
             };

     

       32
       32
        
           };

     

       33
       33
        
         };

+17 -17

nixos/modules/programs/proxychains.nix

···

       26
       26
        
       

     

       27
       27
        
             type = mkOption {

     

       28
       28
        
               type = types.enum [ "http" "socks4" "socks5" ];

     

       29
       29
       -
               description = "Proxy type.";

     

       29
       29
       +
               description = lib.mdDoc "Proxy type.";

     

       30
       30
        
             };

     

       31
       31
        
       

     

       32
       32
        
             host = mkOption {

     

       33
       33
        
               type = types.str;

     

       34
       34
       -
               description = "Proxy host or IP address.";

     

       34
       34
       +
               description = lib.mdDoc "Proxy host or IP address.";

     

       35
       35
        
             };

     

       36
       36
        
       

     

       37
       37
        
             port = mkOption {

     

       38
       38
        
               type = types.port;

     

       39
       39
       -
               description = "Proxy port";

     

       39
       39
       +
               description = lib.mdDoc "Proxy port";

     

       40
       40
        
             };

     

       41
       41
        
           };

     

       42
       42
        
         };

     
···

       55
       55
        
               type = mkOption {

     

       56
       56
        
                 type = types.enum [ "dynamic" "strict" "random" ];

     

       57
       57
        
                 default = "strict";

     

       58
       58
       -
                 description = ''

     

       59
       59
       -
                   <literal>dynamic</literal> - Each connection will be done via chained proxies

     

       58
       58
       +
                 description = lib.mdDoc ''

     

       59
       59
       +
                   `dynamic` - Each connection will be done via chained proxies

     

       60
       60
        
                   all proxies chained in the order as they appear in the list

     

       61
       61
        
                   at least one proxy must be online to play in chain

     

       62
       62
        
                   (dead proxies are skipped)

     

       63
       63
       -
                   otherwise <literal>EINTR</literal> is returned to the app.

     

       63
       63
       +
                   otherwise `EINTR` is returned to the app.

     

       64
       64
        
       

     

       65
       65
       -
                   <literal>strict</literal> - Each connection will be done via chained proxies

     

       65
       65
       +
                   `strict` - Each connection will be done via chained proxies

     

       66
       66
        
                   all proxies chained in the order as they appear in the list

     

       67
       67
        
                   all proxies must be online to play in chain

     

       68
       68
       -
                   otherwise <literal>EINTR</literal> is returned to the app.

     

       68
       68
       +
                   otherwise `EINTR` is returned to the app.

     

       69
       69
        
       

     

       70
       70
       -
                   <literal>random</literal> - Each connection will be done via random proxy

     

       71
       71
       -
                   (or proxy chain, see <option>programs.proxychains.chain.length</option>) from the list.

     

       70
       70
       +
                   `random` - Each connection will be done via random proxy

     

       71
       71
       +
                   (or proxy chain, see {option}`programs.proxychains.chain.length`) from the list.

     

       72
       72
        
                 '';

     

       73
       73
        
               };

     

       74
       74
        
               length = mkOption {

     

       75
       75
        
                 type = types.nullOr types.int;

     

       76
       76
        
                 default = null;

     

       77
       77
       -
                 description = ''

     

       77
       77
       +
                 description = lib.mdDoc ''

     

       78
       78
        
                   Chain length for random chain.

     

       79
       79
        
                 '';

     

       80
       80
        
               };

     
···

       83
       83
        
             proxyDNS = mkOption {

     

       84
       84
        
               type = types.bool;

     

       85
       85
        
               default = true;

     

       86
       86
       -
               description = "Proxy DNS requests - no leak for DNS data.";

     

       86
       86
       +
               description = lib.mdDoc "Proxy DNS requests - no leak for DNS data.";

     

       87
       87
        
             };

     

       88
       88
        
       

     

       89
       89
        
             quietMode = mkEnableOption "Quiet mode (no output from the library).";

     
···

       91
       91
        
             remoteDNSSubnet = mkOption {

     

       92
       92
        
               type = types.enum [ 10 127 224 ];

     

       93
       93
        
               default = 224;

     

       94
       94
       -
               description = ''

     

       94
       94
       +
               description = lib.mdDoc ''

     

       95
       95
        
                 Set the class A subnet number to use for the internal remote DNS mapping, uses the reserved 224.x.x.x range by default.

     

       96
       96
        
               '';

     

       97
       97
        
             };

     
···

       99
       99
        
             tcpReadTimeOut = mkOption {

     

       100
       100
        
               type = types.int;

     

       101
       101
        
               default = 15000;

     

       102
       102
       -
               description = "Connection read time-out in milliseconds.";

     

       102
       102
       +
               description = lib.mdDoc "Connection read time-out in milliseconds.";

     

       103
       103
        
             };

     

       104
       104
        
       

     

       105
       105
        
             tcpConnectTimeOut = mkOption {

     

       106
       106
        
               type = types.int;

     

       107
       107
        
               default = 8000;

     

       108
       108
       -
               description = "Connection time-out in milliseconds.";

     

       108
       108
       +
               description = lib.mdDoc "Connection time-out in milliseconds.";

     

       109
       109
        
             };

     

       110
       110
        
       

     

       111
       111
        
             localnet = mkOption {

     

       112
       112
        
               type = types.str;

     

       113
       113
        
               default = "127.0.0.0/255.0.0.0";

     

       114
       114
       -
               description = "By default enable localnet for loopback address ranges.";

     

       114
       114
       +
               description = lib.mdDoc "By default enable localnet for loopback address ranges.";

     

       115
       115
        
             };

     

       116
       116
        
       

     

       117
       117
        
             proxies = mkOption {

     

       118
       118
        
               type = types.attrsOf (types.submodule proxyOptions);

     

       119
       119
       -
               description = ''

     

       119
       119
       +
               description = lib.mdDoc ''

     

       120
       120
        
                 Proxies to be used by proxychains.

     

       121
       121
        
               '';

     

       122
       122

+5 -5

nixos/modules/programs/spacefm.nix

···

       17
       17
        
             enable = mkOption {

     

       18
       18
        
               type = types.bool;

     

       19
       19
        
               default = false;

     

       20
       20
       -
               description = ''

     

       21
       21
       -
                 Whether to install SpaceFM and create <filename>/etc/spacefm/spacefm.conf</filename>.

     

       20
       20
       +
               description = lib.mdDoc ''

     

       21
       21
       +
                 Whether to install SpaceFM and create {file}`/etc/spacefm/spacefm.conf`.

     

       22
       22
        
               '';

     

       23
       23
        
             };

     

       24
       24
        
       

     
···

       34
       34
        
                   terminal_su = "''${pkgs.sudo}/bin/sudo";

     

       35
       35
        
                 }

     

       36
       36
        
               '';

     

       37
       37
       -
               description = ''

     

       37
       37
       +
               description = lib.mdDoc ''

     

       38
       38
        
                 The system-wide spacefm configuration.

     

       39
       39
       -
                 Parameters to be written to <filename>/etc/spacefm/spacefm.conf</filename>.

     

       40
       40
       -
                 Refer to the <link xlink:href="https://ignorantguru.github.io/spacefm/spacefm-manual-en.html#programfiles-etc">relevant entry</link> in the SpaceFM manual.

     

       39
       39
       +
                 Parameters to be written to {file}`/etc/spacefm/spacefm.conf`.

     

       40
       40
       +
                 Refer to the [relevant entry](https://ignorantguru.github.io/spacefm/spacefm-manual-en.html#programfiles-etc) in the SpaceFM manual.

     

       41
       41
        
               '';

     

       42
       42
        
             };

     

       43
       43

+2 -2

nixos/modules/programs/starship.nix

···

       16
       16
        
           settings = mkOption {

     

       17
       17
        
             inherit (settingsFormat) type;

     

       18
       18
        
             default = { };

     

       19
       19
       -
             description = ''

     

       20
       20
       -
               Configuration included in <literal>starship.toml</literal>.

     

       19
       19
       +
             description = lib.mdDoc ''

     

       20
       20
       +
               Configuration included in `starship.toml`.

     

       21
       21
        
       

     

       22
       22
        
               See https://starship.rs/config/#prompt for documentation.

     

       23
       23
        
             '';

+2 -2

nixos/modules/security/lock-kernel-modules.nix

···

       11
       11
        
           security.lockKernelModules = mkOption {

     

       12
       12
        
             type = types.bool;

     

       13
       13
        
             default = false;

     

       14
       14
       -
             description = ''

     

       14
       14
       +
             description = lib.mdDoc ''

     

       15
       15
        
               Disable kernel module loading once the system is fully initialised.

     

       16
       16
        
               Module loading is disabled until the next reboot. Problems caused

     

       17
       17
        
               by delayed module loading can be fixed by adding the module(s) in

     

       18
       18
       -
               question to <option>boot.kernelModules</option>.

     

       18
       18
       +
               question to {option}`boot.kernelModules`.

     

       19
       19
        
             '';

     

       20
       20
        
           };

     

       21
       21
        
         };

+4 -4

nixos/modules/security/polkit.nix

···

       29
       29
        
                   if (subject.local) return "yes";

     

       30
       30
        
                 });

     

       31
       31
        
               '';

     

       32
       32
       -
             description =

     

       32
       32
       +
             description = lib.mdDoc

     

       33
       33
        
               ''

     

       34
       34
        
                 Any polkit rules to be added to config (in JavaScript ;-). See:

     

       35
       35
        
                 http://www.freedesktop.org/software/polkit/docs/latest/polkit.8.html#polkit-rules

     
···

       40
       40
        
             type = types.listOf types.str;

     

       41
       41
        
             default = [ "unix-group:wheel" ];

     

       42
       42
        
             example = [ "unix-user:alice" "unix-group:admin" ];

     

       43
       43
       -
             description =

     

       43
       43
       +
             description = lib.mdDoc

     

       44
       44
        
               ''

     

       45
       45
        
                 Specifies which users are considered “administrators”, for those

     

       46
       46
        
                 actions that require the user to authenticate as an

     

       47
       47
       -
                 administrator (i.e. have an <literal>auth_admin</literal>

     

       48
       48
       -
                 value).  By default, this is all users in the <literal>wheel</literal> group.

     

       47
       47
       +
                 administrator (i.e. have an `auth_admin`

     

       48
       48
       +
                 value).  By default, this is all users in the `wheel` group.

     

       49
       49
        
               '';

     

       50
       50
        
           };

     

       51
       51

+5 -5

nixos/modules/system/boot/loader/generations-dir/generations-dir.nix

···

       22
       22
        
             enable = mkOption {

     

       23
       23
        
               default = false;

     

       24
       24
        
               type = types.bool;

     

       25
       25
       -
               description = ''

     

       25
       25
       +
               description = lib.mdDoc ''

     

       26
       26
        
                 Whether to create symlinks to the system generations under

     

       27
       27
       -
                 <literal>/boot</literal>.  When enabled,

     

       28
       28
       -
                 <literal>/boot/default/kernel</literal>,

     

       29
       29
       -
                 <literal>/boot/default/initrd</literal>, etc., are updated to

     

       27
       27
       +
                 `/boot`.  When enabled,

     

       28
       28
       +
                 `/boot/default/kernel`,

     

       29
       29
       +
                 `/boot/default/initrd`, etc., are updated to

     

       30
       30
        
                 point to the current generation's kernel image, initial RAM

     

       31
       31
        
                 disk, and other bootstrap files.

     

       32
       32
        
       

     
···

       41
       41
        
             copyKernels = mkOption {

     

       42
       42
        
               default = false;

     

       43
       43
        
               type = types.bool;

     

       44
       44
       -
               description = ''

     

       44
       44
       +
               description = lib.mdDoc ''

     

       45
       45
        
                 Whether copy the necessary boot files into /boot, so

     

       46
       46
        
                 /nix/store is not needed by the boot loader.

     

       47
       47
        
               '';

+35 -35

nixos/modules/system/boot/systemd.nix

···

       177
       177
        
             default = pkgs.systemd;

     

       178
       178
        
             defaultText = literalExpression "pkgs.systemd";

     

       179
       179
        
             type = types.package;

     

       180
       180
       -
             description = "The systemd package.";

     

       180
       180
       +
             description = lib.mdDoc "The systemd package.";

     

       181
       181
        
           };

     

       182
       182
        
       

     

       183
       183
        
           systemd.units = mkOption {

     

       184
       184
       -
             description = "Definition of systemd units.";

     

       184
       184
       +
             description = lib.mdDoc "Definition of systemd units.";

     

       185
       185
        
             default = {};

     

       186
       186
        
             type = systemdUtils.types.units;

     

       187
       187
        
           };

     
···

       190
       190
        
             default = [];

     

       191
       191
        
             type = types.listOf types.package;

     

       192
       192
        
             example = literalExpression "[ pkgs.systemd-cryptsetup-generator ]";

     

       193
       193
       -
             description = "Packages providing systemd units and hooks.";

     

       193
       193
       +
             description = lib.mdDoc "Packages providing systemd units and hooks.";

     

       194
       194
        
           };

     

       195
       195
        
       

     

       196
       196
        
           systemd.targets = mkOption {

     

       197
       197
        
             default = {};

     

       198
       198
        
             type = systemdUtils.types.targets;

     

       199
       199
       -
             description = "Definition of systemd target units.";

     

       199
       199
       +
             description = lib.mdDoc "Definition of systemd target units.";

     

       200
       200
        
           };

     

       201
       201
        
       

     

       202
       202
        
           systemd.services = mkOption {

     

       203
       203
        
             default = {};

     

       204
       204
        
             type = systemdUtils.types.services;

     

       205
       205
       -
             description = "Definition of systemd service units.";

     

       205
       205
       +
             description = lib.mdDoc "Definition of systemd service units.";

     

       206
       206
        
           };

     

       207
       207
        
       

     

       208
       208
        
           systemd.sockets = mkOption {

     

       209
       209
        
             default = {};

     

       210
       210
        
             type = systemdUtils.types.sockets;

     

       211
       211
       -
             description = "Definition of systemd socket units.";

     

       211
       211
       +
             description = lib.mdDoc "Definition of systemd socket units.";

     

       212
       212
        
           };

     

       213
       213
        
       

     

       214
       214
        
           systemd.timers = mkOption {

     

       215
       215
        
             default = {};

     

       216
       216
        
             type = systemdUtils.types.timers;

     

       217
       217
       -
             description = "Definition of systemd timer units.";

     

       217
       217
       +
             description = lib.mdDoc "Definition of systemd timer units.";

     

       218
       218
        
           };

     

       219
       219
        
       

     

       220
       220
        
           systemd.paths = mkOption {

     

       221
       221
        
             default = {};

     

       222
       222
        
             type = systemdUtils.types.paths;

     

       223
       223
       -
             description = "Definition of systemd path units.";

     

       223
       223
       +
             description = lib.mdDoc "Definition of systemd path units.";

     

       224
       224
        
           };

     

       225
       225
        
       

     

       226
       226
        
           systemd.mounts = mkOption {

     

       227
       227
        
             default = [];

     

       228
       228
        
             type = systemdUtils.types.mounts;

     

       229
       229
       -
             description = ''

     

       229
       229
       +
             description = lib.mdDoc ''

     

       230
       230
        
               Definition of systemd mount units.

     

       231
       231
        
               This is a list instead of an attrSet, because systemd mandates the names to be derived from

     

       232
       232
        
               the 'where' attribute.

     
···

       236
       236
        
           systemd.automounts = mkOption {

     

       237
       237
        
             default = [];

     

       238
       238
        
             type = systemdUtils.types.automounts;

     

       239
       239
       -
             description = ''

     

       239
       239
       +
             description = lib.mdDoc ''

     

       240
       240
        
               Definition of systemd automount units.

     

       241
       241
        
               This is a list instead of an attrSet, because systemd mandates the names to be derived from

     

       242
       242
        
               the 'where' attribute.

     
···

       246
       246
        
           systemd.slices = mkOption {

     

       247
       247
        
             default = {};

     

       248
       248
        
             type = systemdUtils.types.slices;

     

       249
       249
       -
             description = "Definition of slice configurations.";

     

       249
       249
       +
             description = lib.mdDoc "Definition of slice configurations.";

     

       250
       250
        
           };

     

       251
       251
        
       

     

       252
       252
        
           systemd.generators = mkOption {

     

       253
       253
        
             type = types.attrsOf types.path;

     

       254
       254
        
             default = {};

     

       255
       255
        
             example = { systemd-gpt-auto-generator = "/dev/null"; };

     

       256
       256
       -
             description = ''

     

       256
       256
       +
             description = lib.mdDoc ''

     

       257
       257
        
               Definition of systemd generators.

     

       258
       258
       -
               For each <literal>NAME = VALUE</literal> pair of the attrSet, a link is generated from

     

       259
       259
       -
               <literal>/etc/systemd/system-generators/NAME</literal> to <literal>VALUE</literal>.

     

       258
       258
       +
               For each `NAME = VALUE` pair of the attrSet, a link is generated from

     

       259
       259
       +
               `/etc/systemd/system-generators/NAME` to `VALUE`.

     

       260
       260
        
             '';

     

       261
       261
        
           };

     

       262
       262
        
       

     

       263
       263
        
           systemd.shutdown = mkOption {

     

       264
       264
        
             type = types.attrsOf types.path;

     

       265
       265
        
             default = {};

     

       266
       266
       -
             description = ''

     

       266
       266
       +
             description = lib.mdDoc ''

     

       267
       267
        
               Definition of systemd shutdown executables.

     

       268
       268
       -
               For each <literal>NAME = VALUE</literal> pair of the attrSet, a link is generated from

     

       269
       269
       -
               <literal>/etc/systemd/system-shutdown/NAME</literal> to <literal>VALUE</literal>.

     

       268
       268
       +
               For each `NAME = VALUE` pair of the attrSet, a link is generated from

     

       269
       269
       +
               `/etc/systemd/system-shutdown/NAME` to `VALUE`.

     

       270
       270
        
             '';

     

       271
       271
        
           };

     

       272
       272
        
       

     

       273
       273
        
           systemd.defaultUnit = mkOption {

     

       274
       274
        
             default = "multi-user.target";

     

       275
       275
        
             type = types.str;

     

       276
       276
       -
             description = "Default unit started when the system boots.";

     

       276
       276
       +
             description = lib.mdDoc "Default unit started when the system boots.";

     

       277
       277
        
           };

     

       278
       278
        
       

     

       279
       279
        
           systemd.ctrlAltDelUnit = mkOption {

     

       280
       280
        
             default = "reboot.target";

     

       281
       281
        
             type = types.str;

     

       282
       282
        
             example = "poweroff.target";

     

       283
       283
       -
             description = ''

     

       283
       283
       +
             description = lib.mdDoc ''

     

       284
       284
        
               Target that should be started when Ctrl-Alt-Delete is pressed.

     

       285
       285
        
             '';

     

       286
       286
        
           };

     
···

       289
       289
        
             type = with types; attrsOf (nullOr (oneOf [ str path package ]));

     

       290
       290
        
             default = {};

     

       291
       291
        
             example = { TZ = "CET"; };

     

       292
       292
       -
             description = ''

     

       293
       293
       -
               Environment variables passed to <emphasis>all</emphasis> systemd units.

     

       292
       292
       +
             description = lib.mdDoc ''

     

       293
       293
       +
               Environment variables passed to *all* systemd units.

     

       294
       294
        
             '';

     

       295
       295
        
           };

     

       296
       296
        
       

     
···

       298
       298
        
             type = with types; attrsOf (nullOr (oneOf [ str path package ]));

     

       299
       299
        
             default = {};

     

       300
       300
        
             example = { SYSTEMD_LOG_LEVEL = "debug"; };

     

       301
       301
       -
             description = ''

     

       301
       301
       +
             description = lib.mdDoc ''

     

       302
       302
        
               Environment variables of PID 1. These variables are

     

       303
       303
       -
               <emphasis>not</emphasis> passed to started units.

     

       303
       303
       +
               *not* passed to started units.

     

       304
       304
        
             '';

     

       305
       305
        
           };

     

       306
       306
        
       

     

       307
       307
        
           systemd.enableCgroupAccounting = mkOption {

     

       308
       308
        
             default = true;

     

       309
       309
        
             type = types.bool;

     

       310
       310
       -
             description = ''

     

       310
       310
       +
             description = lib.mdDoc ''

     

       311
       311
        
               Whether to enable cgroup accounting.

     

       312
       312
        
             '';

     

       313
       313
        
           };

     
···

       315
       315
        
           systemd.enableUnifiedCgroupHierarchy = mkOption {

     

       316
       316
        
             default = true;

     

       317
       317
        
             type = types.bool;

     

       318
       318
       -
             description = ''

     

       318
       318
       +
             description = lib.mdDoc ''

     

       319
       319
        
               Whether to enable the unified cgroup hierarchy (cgroupsv2).

     

       320
       320
        
             '';

     

       321
       321
        
           };

     
···

       324
       324
        
             default = "";

     

       325
       325
        
             type = types.lines;

     

       326
       326
        
             example = "DefaultLimitCORE=infinity";

     

       327
       327
       -
             description = ''

     

       327
       327
       +
             description = lib.mdDoc ''

     

       328
       328
        
               Extra config options for systemd. See man systemd-system.conf for

     

       329
       329
        
               available options.

     

       330
       330
        
             '';

     
···

       334
       334
        
             default = "";

     

       335
       335
        
             type = types.lines;

     

       336
       336
        
             example = "HibernateDelaySec=1h";

     

       337
       337
       -
             description = ''

     

       337
       337
       +
             description = lib.mdDoc ''

     

       338
       338
        
               Extra config options for systemd sleep state logic.

     

       339
       339
        
               See sleep.conf.d(5) man page for available options.

     

       340
       340
        
             '';

     
···

       344
       344
        
             default = [ ];

     

       345
       345
        
             type = types.listOf types.str;

     

       346
       346
        
             example = [ "debug-shell.service" "systemd-quotacheck.service" ];

     

       347
       347
       -
             description = ''

     

       347
       347
       +
             description = lib.mdDoc ''

     

       348
       348
        
               Additional units shipped with systemd that shall be enabled.

     

       349
       349
        
             '';

     

       350
       350
        
           };

     
···

       353
       353
        
             default = [ ];

     

       354
       354
        
             type = types.listOf types.str;

     

       355
       355
        
             example = [ "systemd-backlight@.service" ];

     

       356
       356
       -
             description = ''

     

       356
       356
       +
             description = lib.mdDoc ''

     

       357
       357
        
               A list of units to skip when generating system systemd configuration directory. This has

     

       358
       358
       -
               priority over upstream units, <option>systemd.units</option>, and

     

       359
       359
       -
               <option>systemd.additionalUpstreamSystemUnits</option>. The main purpose of this is to

     

       358
       358
       +
               priority over upstream units, {option}`systemd.units`, and

     

       359
       359
       +
               {option}`systemd.additionalUpstreamSystemUnits`. The main purpose of this is to

     

       360
       360
        
               prevent a upstream systemd unit from being added to the initrd with any modifications made to it

     

       361
       361
        
               by other NixOS modules.

     

       362
       362
        
             '';

     
···

       366
       366
        
             type = types.nullOr types.path;

     

       367
       367
        
             default = null;

     

       368
       368
        
             example = "/dev/watchdog";

     

       369
       369
       -
             description = ''

     

       369
       369
       +
             description = lib.mdDoc ''

     

       370
       370
        
               The path to a hardware watchdog device which will be managed by systemd.

     

       371
       371
        
               If not specified, systemd will default to /dev/watchdog.

     

       372
       372
        
             '';

     
···

       376
       376
        
             type = types.nullOr types.str;

     

       377
       377
        
             default = null;

     

       378
       378
        
             example = "30s";

     

       379
       379
       -
             description = ''

     

       379
       379
       +
             description = lib.mdDoc ''

     

       380
       380
        
               The amount of time which can elapse before a watchdog hardware device

     

       381
       381
        
               will automatically reboot the system. Valid time units include "ms",

     

       382
       382
        
               "s", "min", "h", "d", and "w".

     
···

       387
       387
        
             type = types.nullOr types.str;

     

       388
       388
        
             default = null;

     

       389
       389
        
             example = "10m";

     

       390
       390
       -
             description = ''

     

       390
       390
       +
             description = lib.mdDoc ''

     

       391
       391
        
               The amount of time which can elapse after a reboot has been triggered

     

       392
       392
        
               before a watchdog hardware device will automatically reboot the system.

     

       393
       393
        
               Valid time units include "ms", "s", "min", "h", "d", and "w".

     
···

       398
       398
        
             type = types.nullOr types.str;

     

       399
       399
        
             default = null;

     

       400
       400
        
             example = "10m";

     

       401
       401
       -
             description = ''

     

       401
       401
       +
             description = lib.mdDoc ''

     

       402
       402
        
               The amount of time which can elapse when kexec is being executed before

     

       403
       403
        
               a watchdog hardware device will automatically reboot the system. This

     

       404
       404
        
               option should only be enabled if reloadTime is also enabled. Valid

+20 -20

nixos/modules/system/boot/systemd/initrd.nix

···

       150
       150
        
           };

     

       151
       151
        
       

     

       152
       152
        
           contents = mkOption {

     

       153
       153
       -
             description = "Set of files that have to be linked into the initrd";

     

       153
       153
       +
             description = lib.mdDoc "Set of files that have to be linked into the initrd";

     

       154
       154
        
             example = literalExpression ''

     

       155
       155
        
               {

     

       156
       156
        
                 "/etc/hostname".text = "mymachine";

     
···

       162
       162
        
           };

     

       163
       163
        
       

     

       164
       164
        
           storePaths = mkOption {

     

       165
       165
       -
             description = ''

     

       165
       165
       +
             description = lib.mdDoc ''

     

       166
       166
        
               Store paths to copy into the initrd as well.

     

       167
       167
        
             '';

     

       168
       168
        
             type = with types; listOf (oneOf [ singleLineStr package ]);

     
···

       170
       170
        
           };

     

       171
       171
        
       

     

       172
       172
        
           extraBin = mkOption {

     

       173
       173
       -
             description = ''

     

       173
       173
       +
             description = lib.mdDoc ''

     

       174
       174
        
               Tools to add to /bin

     

       175
       175
        
             '';

     

       176
       176
        
             example = literalExpression ''

     
···

       183
       183
        
           };

     

       184
       184
        
       

     

       185
       185
        
           suppressedStorePaths = mkOption {

     

       186
       186
       -
             description = ''

     

       186
       186
       +
             description = lib.mdDoc ''

     

       187
       187
        
               Store paths specified in the storePaths option that

     

       188
       188
        
               should not be copied.

     

       189
       189
        
             '';

     
···

       194
       194
        
           emergencyAccess = mkOption {

     

       195
       195
        
             type = with types; oneOf [ bool (nullOr (passwdEntry str)) ];

     

       196
       196
        
             visible = false;

     

       197
       197
       -
             description = ''

     

       197
       197
       +
             description = lib.mdDoc ''

     

       198
       198
        
               Set to true for unauthenticated emergency access, and false for

     

       199
       199
        
               no emergency access.

     

       200
       200
        
       

     
···

       208
       208
        
             type = types.listOf types.package;

     

       209
       209
        
             default = [];

     

       210
       210
        
             visible = false;

     

       211
       211
       -
             description = ''

     

       211
       211
       +
             description = lib.mdDoc ''

     

       212
       212
        
               Packages to include in /bin for the stage 1 emergency shell.

     

       213
       213
        
             '';

     

       214
       214
        
           };

     
···

       218
       218
        
             type = types.listOf types.str;

     

       219
       219
        
             visible = false;

     

       220
       220
        
             example = [ "debug-shell.service" "systemd-quotacheck.service" ];

     

       221
       221
       -
             description = ''

     

       221
       221
       +
             description = lib.mdDoc ''

     

       222
       222
        
               Additional units shipped with systemd that shall be enabled.

     

       223
       223
        
             '';

     

       224
       224
        
           };

     
···

       228
       228
        
             type = types.listOf types.str;

     

       229
       229
        
             example = [ "systemd-backlight@.service" ];

     

       230
       230
        
             visible = false;

     

       231
       231
       -
             description = ''

     

       231
       231
       +
             description = lib.mdDoc ''

     

       232
       232
        
               A list of units to skip when generating system systemd configuration directory. This has

     

       233
       233
       -
               priority over upstream units, <option>boot.initrd.systemd.units</option>, and

     

       234
       234
       -
               <option>boot.initrd.systemd.additionalUpstreamUnits</option>. The main purpose of this is to

     

       233
       233
       +
               priority over upstream units, {option}`boot.initrd.systemd.units`, and

     

       234
       234
       +
               {option}`boot.initrd.systemd.additionalUpstreamUnits`. The main purpose of this is to

     

       235
       235
        
               prevent a upstream systemd unit from being added to the initrd with any modifications made to it

     

       236
       236
        
               by other NixOS modules.

     

       237
       237
        
             '';

     

       238
       238
        
           };

     

       239
       239
        
       

     

       240
       240
        
           units = mkOption {

     

       241
       241
       -
             description = "Definition of systemd units.";

     

       241
       241
       +
             description = lib.mdDoc "Definition of systemd units.";

     

       242
       242
        
             default = {};

     

       243
       243
        
             visible = false;

     

       244
       244
        
             type = systemdUtils.types.units;

     
···

       249
       249
        
             visible = false;

     

       250
       250
        
             type = types.listOf types.package;

     

       251
       251
        
             example = literalExpression "[ pkgs.systemd-cryptsetup-generator ]";

     

       252
       252
       -
             description = "Packages providing systemd units and hooks.";

     

       252
       252
       +
             description = lib.mdDoc "Packages providing systemd units and hooks.";

     

       253
       253
        
           };

     

       254
       254
        
       

     

       255
       255
        
           targets = mkOption {

     

       256
       256
        
             default = {};

     

       257
       257
        
             visible = false;

     

       258
       258
        
             type = systemdUtils.types.initrdTargets;

     

       259
       259
       -
             description = "Definition of systemd target units.";

     

       259
       259
       +
             description = lib.mdDoc "Definition of systemd target units.";

     

       260
       260
        
           };

     

       261
       261
        
       

     

       262
       262
        
           services = mkOption {

     

       263
       263
        
             default = {};

     

       264
       264
        
             type = systemdUtils.types.initrdServices;

     

       265
       265
        
             visible = false;

     

       266
       266
       -
             description = "Definition of systemd service units.";

     

       266
       266
       +
             description = lib.mdDoc "Definition of systemd service units.";

     

       267
       267
        
           };

     

       268
       268
        
       

     

       269
       269
        
           sockets = mkOption {

     

       270
       270
        
             default = {};

     

       271
       271
        
             type = systemdUtils.types.initrdSockets;

     

       272
       272
        
             visible = false;

     

       273
       273
       -
             description = "Definition of systemd socket units.";

     

       273
       273
       +
             description = lib.mdDoc "Definition of systemd socket units.";

     

       274
       274
        
           };

     

       275
       275
        
       

     

       276
       276
        
           timers = mkOption {

     

       277
       277
        
             default = {};

     

       278
       278
        
             type = systemdUtils.types.initrdTimers;

     

       279
       279
        
             visible = false;

     

       280
       280
       -
             description = "Definition of systemd timer units.";

     

       280
       280
       +
             description = lib.mdDoc "Definition of systemd timer units.";

     

       281
       281
        
           };

     

       282
       282
        
       

     

       283
       283
        
           paths = mkOption {

     

       284
       284
        
             default = {};

     

       285
       285
        
             type = systemdUtils.types.initrdPaths;

     

       286
       286
        
             visible = false;

     

       287
       287
       -
             description = "Definition of systemd path units.";

     

       287
       287
       +
             description = lib.mdDoc "Definition of systemd path units.";

     

       288
       288
        
           };

     

       289
       289
        
       

     

       290
       290
        
           mounts = mkOption {

     

       291
       291
        
             default = [];

     

       292
       292
        
             type = systemdUtils.types.initrdMounts;

     

       293
       293
        
             visible = false;

     

       294
       294
       -
             description = ''

     

       294
       294
       +
             description = lib.mdDoc ''

     

       295
       295
        
               Definition of systemd mount units.

     

       296
       296
        
               This is a list instead of an attrSet, because systemd mandates the names to be derived from

     

       297
       297
        
               the 'where' attribute.

     
···

       302
       302
        
             default = [];

     

       303
       303
        
             type = systemdUtils.types.automounts;

     

       304
       304
        
             visible = false;

     

       305
       305
       -
             description = ''

     

       305
       305
       +
             description = lib.mdDoc ''

     

       306
       306
        
               Definition of systemd automount units.

     

       307
       307
        
               This is a list instead of an attrSet, because systemd mandates the names to be derived from

     

       308
       308
        
               the 'where' attribute.

     
···

       313
       313
        
             default = {};

     

       314
       314
        
             type = systemdUtils.types.slices;

     

       315
       315
        
             visible = false;

     

       316
       316
       -
             description = "Definition of slice configurations.";

     

       316
       316
       +
             description = lib.mdDoc "Definition of slice configurations.";

     

       317
       317
        
           };

     

       318
       318
        
         };

     

       319
       319

+5 -5

nixos/modules/system/boot/tmp.nix

···

       14
       14
        
           boot.cleanTmpDir = mkOption {

     

       15
       15
        
             type = types.bool;

     

       16
       16
        
             default = false;

     

       17
       17
       -
             description = ''

     

       18
       18
       -
               Whether to delete all files in <filename>/tmp</filename> during boot.

     

       17
       17
       +
             description = lib.mdDoc ''

     

       18
       18
       +
               Whether to delete all files in {file}`/tmp` during boot.

     

       19
       19
        
             '';

     

       20
       20
        
           };

     

       21
       21
        
       

     

       22
       22
        
           boot.tmpOnTmpfs = mkOption {

     

       23
       23
        
             type = types.bool;

     

       24
       24
        
             default = false;

     

       25
       25
       -
             description = ''

     

       26
       26
       -
                Whether to mount a tmpfs on <filename>/tmp</filename> during boot.

     

       25
       25
       +
             description = lib.mdDoc ''

     

       26
       26
       +
                Whether to mount a tmpfs on {file}`/tmp` during boot.

     

       27
       27
        
             '';

     

       28
       28
        
           };

     

       29
       29
        
       

     

       30
       30
        
           boot.tmpOnTmpfsSize = mkOption {

     

       31
       31
        
             type = types.oneOf [ types.str types.types.ints.positive ];

     

       32
       32
        
             default = "50%";

     

       33
       33
       -
             description = ''

     

       33
       33
       +
             description = lib.mdDoc ''

     

       34
       34
        
               Size of tmpfs in percentage.

     

       35
       35
        
               Percentage is defined by systemd.

     

       36
       36
        
             '';

+15 -15

nixos/modules/system/etc/etc.nix

···

       82
       82
        
                 "default/useradd".text = "GROUP=100 ...";

     

       83
       83
        
               }

     

       84
       84
        
             '';

     

       85
       85
       -
             description = ''

     

       86
       86
       -
               Set of files that have to be linked in <filename>/etc</filename>.

     

       85
       85
       +
             description = lib.mdDoc ''

     

       86
       86
       +
               Set of files that have to be linked in {file}`/etc`.

     

       87
       87
        
             '';

     

       88
       88
        
       

     

       89
       89
        
             type = with types; attrsOf (submodule (

     
···

       93
       93
        
                   enable = mkOption {

     

       94
       94
        
                     type = types.bool;

     

       95
       95
        
                     default = true;

     

       96
       96
       -
                     description = ''

     

       96
       96
       +
                     description = lib.mdDoc ''

     

       97
       97
        
                       Whether this /etc file should be generated.  This

     

       98
       98
        
                       option allows specific /etc files to be disabled.

     

       99
       99
        
                     '';

     
···

       101
       101
        
       

     

       102
       102
        
                   target = mkOption {

     

       103
       103
        
                     type = types.str;

     

       104
       104
       -
                     description = ''

     

       104
       104
       +
                     description = lib.mdDoc ''

     

       105
       105
        
                       Name of symlink (relative to

     

       106
       106
       -
                       <filename>/etc</filename>).  Defaults to the attribute

     

       106
       106
       +
                       {file}`/etc`).  Defaults to the attribute

     

       107
       107
        
                       name.

     

       108
       108
        
                     '';

     

       109
       109
        
                   };

     
···

       111
       111
        
                   text = mkOption {

     

       112
       112
        
                     default = null;

     

       113
       113
        
                     type = types.nullOr types.lines;

     

       114
       114
       -
                     description = "Text of the file.";

     

       114
       114
       +
                     description = lib.mdDoc "Text of the file.";

     

       115
       115
        
                   };

     

       116
       116
        
       

     

       117
       117
        
                   source = mkOption {

     

       118
       118
        
                     type = types.path;

     

       119
       119
       -
                     description = "Path of the source file.";

     

       119
       119
       +
                     description = lib.mdDoc "Path of the source file.";

     

       120
       120
        
                   };

     

       121
       121
        
       

     

       122
       122
        
                   mode = mkOption {

     

       123
       123
        
                     type = types.str;

     

       124
       124
        
                     default = "symlink";

     

       125
       125
        
                     example = "0600";

     

       126
       126
       -
                     description = ''

     

       127
       127
       -
                       If set to something else than <literal>symlink</literal>,

     

       126
       126
       +
                     description = lib.mdDoc ''

     

       127
       127
       +
                       If set to something else than `symlink`,

     

       128
       128
        
                       the file is copied instead of symlinked, with the given

     

       129
       129
        
                       file mode.

     

       130
       130
        
                     '';

     
···

       133
       133
        
                   uid = mkOption {

     

       134
       134
        
                     default = 0;

     

       135
       135
        
                     type = types.int;

     

       136
       136
       -
                     description = ''

     

       136
       136
       +
                     description = lib.mdDoc ''

     

       137
       137
        
                       UID of created file. Only takes effect when the file is

     

       138
       138
        
                       copied (that is, the mode is not 'symlink').

     

       139
       139
        
                       '';

     
···

       142
       142
        
                   gid = mkOption {

     

       143
       143
        
                     default = 0;

     

       144
       144
        
                     type = types.int;

     

       145
       145
       -
                     description = ''

     

       145
       145
       +
                     description = lib.mdDoc ''

     

       146
       146
        
                       GID of created file. Only takes effect when the file is

     

       147
       147
        
                       copied (that is, the mode is not 'symlink').

     

       148
       148
        
                     '';

     
···

       151
       151
        
                   user = mkOption {

     

       152
       152
        
                     default = "+${toString config.uid}";

     

       153
       153
        
                     type = types.str;

     

       154
       154
       -
                     description = ''

     

       154
       154
       +
                     description = lib.mdDoc ''

     

       155
       155
        
                       User name of created file.

     

       156
       156
        
                       Only takes effect when the file is copied (that is, the mode is not 'symlink').

     

       157
       157
       -
                       Changing this option takes precedence over <literal>uid</literal>.

     

       157
       157
       +
                       Changing this option takes precedence over `uid`.

     

       158
       158
        
                     '';

     

       159
       159
        
                   };

     

       160
       160
        
       

     

       161
       161
        
                   group = mkOption {

     

       162
       162
        
                     default = "+${toString config.gid}";

     

       163
       163
        
                     type = types.str;

     

       164
       164
       -
                     description = ''

     

       164
       164
       +
                     description = lib.mdDoc ''

     

       165
       165
        
                       Group name of created file.

     

       166
       166
        
                       Only takes effect when the file is copied (that is, the mode is not 'symlink').

     

       167
       167
       -
                       Changing this option takes precedence over <literal>gid</literal>.

     

       167
       167
       +
                       Changing this option takes precedence over `gid`.

     

       168
       168
        
                     '';

     

       169
       169
        
                   };

     

       170
       170

+7 -7

nixos/modules/tasks/encrypted-devices.nix

···

       16
       16
        
             enable = mkOption {

     

       17
       17
        
               default = false;

     

       18
       18
        
               type = types.bool;

     

       19
       19
       -
               description = "The block device is backed by an encrypted one, adds this device as a initrd luks entry.";

     

       19
       19
       +
               description = lib.mdDoc "The block device is backed by an encrypted one, adds this device as a initrd luks entry.";

     

       20
       20
        
             };

     

       21
       21
        
       

     

       22
       22
        
             blkDev = mkOption {

     

       23
       23
        
               default = null;

     

       24
       24
        
               example = "/dev/sda1";

     

       25
       25
        
               type = types.nullOr types.str;

     

       26
       26
       -
               description = "Location of the backing encrypted device.";

     

       26
       26
       +
               description = lib.mdDoc "Location of the backing encrypted device.";

     

       27
       27
        
             };

     

       28
       28
        
       

     

       29
       29
        
             label = mkOption {

     

       30
       30
        
               default = null;

     

       31
       31
        
               example = "rootfs";

     

       32
       32
        
               type = types.nullOr types.str;

     

       33
       33
       -
               description = "Label of the unlocked encrypted device. Set <literal>fileSystems.&lt;name?&gt;.device</literal> to <literal>/dev/mapper/&lt;label&gt;</literal> to mount the unlocked device.";

     

       33
       33
       +
               description = lib.mdDoc "Label of the unlocked encrypted device. Set `fileSystems.<name?>.device` to `/dev/mapper/<label>` to mount the unlocked device.";

     

       34
       34
        
             };

     

       35
       35
        
       

     

       36
       36
        
             keyFile = mkOption {

     

       37
       37
        
               default = null;

     

       38
       38
        
               example = "/mnt-root/root/.swapkey";

     

       39
       39
        
               type = types.nullOr types.str;

     

       40
       40
       -
               description = ''

     

       40
       40
       +
               description = lib.mdDoc ''

     

       41
       41
        
                 Path to a keyfile used to unlock the backing encrypted

     

       42
       42
        
                 device. At the time this keyfile is accessed, the

     

       43
       43
       -
                 <literal>neededForBoot</literal> filesystems (see

     

       44
       44
       -
                 <literal>fileSystems.&lt;name?&gt;.neededForBoot</literal>)

     

       45
       45
       -
                 will have been mounted under <literal>/mnt-root</literal>,

     

       43
       43
       +
                 `neededForBoot` filesystems (see

     

       44
       44
       +
                 `fileSystems.<name?>.neededForBoot`)

     

       45
       45
       +
                 will have been mounted under `/mnt-root`,

     

       46
       46
        
                 so the keyfile path should usually start with "/mnt-root/".

     

       47
       47
        
               '';

     

       48
       48
        
             };

+12 -12

nixos/modules/tasks/snapraid.nix

···

       14
       14
        
               d2 = "/mnt/disk2/";

     

       15
       15
        
               d3 = "/mnt/disk3/";

     

       16
       16
        
             };

     

       17
       17
       -
             description = "SnapRAID data disks.";

     

       17
       17
       +
             description = lib.mdDoc "SnapRAID data disks.";

     

       18
       18
        
             type = attrsOf str;

     

       19
       19
        
           };

     

       20
       20
        
           parityFiles = mkOption {

     
···

       27
       27
        
               "/mnt/diskt/snapraid.5-parity"

     

       28
       28
        
               "/mnt/disku/snapraid.6-parity"

     

       29
       29
        
             ];

     

       30
       30
       -
             description = "SnapRAID parity files.";

     

       30
       30
       +
             description = lib.mdDoc "SnapRAID parity files.";

     

       31
       31
        
             type = listOf str;

     

       32
       32
        
           };

     

       33
       33
        
           contentFiles = mkOption {

     
···

       37
       37
        
               "/mnt/disk1/snapraid.content"

     

       38
       38
        
               "/mnt/disk2/snapraid.content"

     

       39
       39
        
             ];

     

       40
       40
       -
             description = "SnapRAID content list files.";

     

       40
       40
       +
             description = lib.mdDoc "SnapRAID content list files.";

     

       41
       41
        
             type = listOf str;

     

       42
       42
        
           };

     

       43
       43
        
           exclude = mkOption {

     

       44
       44
        
             default = [ ];

     

       45
       45
        
             example = [ "*.unrecoverable" "/tmp/" "/lost+found/" ];

     

       46
       46
       -
             description = "SnapRAID exclude directives.";

     

       46
       46
       +
             description = lib.mdDoc "SnapRAID exclude directives.";

     

       47
       47
        
             type = listOf str;

     

       48
       48
        
           };

     

       49
       49
        
           touchBeforeSync = mkOption {

     

       50
       50
        
             default = true;

     

       51
       51
        
             example = false;

     

       52
       52
       -
             description =

     

       53
       53
       -
               "Whether <command>snapraid touch</command> should be run before <command>snapraid sync</command>.";

     

       52
       52
       +
             description = lib.mdDoc

     

       53
       53
       +
               "Whether {command}`snapraid touch` should be run before {command}`snapraid sync`.";

     

       54
       54
        
             type = bool;

     

       55
       55
        
           };

     

       56
       56
        
           sync.interval = mkOption {

     

       57
       57
        
             default = "01:00";

     

       58
       58
        
             example = "daily";

     

       59
       59
       -
             description = "How often to run <command>snapraid sync</command>.";

     

       59
       59
       +
             description = lib.mdDoc "How often to run {command}`snapraid sync`.";

     

       60
       60
        
             type = str;

     

       61
       61
        
           };

     

       62
       62
        
           scrub = {

     

       63
       63
        
             interval = mkOption {

     

       64
       64
        
               default = "Mon *-*-* 02:00:00";

     

       65
       65
        
               example = "weekly";

     

       66
       66
       -
               description = "How often to run <command>snapraid scrub</command>.";

     

       66
       66
       +
               description = lib.mdDoc "How often to run {command}`snapraid scrub`.";

     

       67
       67
        
               type = str;

     

       68
       68
        
             };

     

       69
       69
        
             plan = mkOption {

     

       70
       70
        
               default = 8;

     

       71
       71
        
               example = 5;

     

       72
       72
       -
               description =

     

       73
       73
       -
                 "Percent of the array that should be checked by <command>snapraid scrub</command>.";

     

       72
       72
       +
               description = lib.mdDoc

     

       73
       73
       +
                 "Percent of the array that should be checked by {command}`snapraid scrub`.";

     

       74
       74
        
               type = int;

     

       75
       75
        
             };

     

       76
       76
        
             olderThan = mkOption {

     

       77
       77
        
               default = 10;

     

       78
       78
        
               example = 20;

     

       79
       79
       -
               description =

     

       79
       79
       +
               description = lib.mdDoc

     

       80
       80
        
                 "Number of days since data was last scrubbed before it can be scrubbed again.";

     

       81
       81
        
               type = int;

     

       82
       82
        
             };

     
···

       90
       90
        
               autosave 500

     

       91
       91
        
               pool /pool

     

       92
       92
        
             '';

     

       93
       93
       -
             description = "Extra config options for SnapRAID.";

     

       93
       93
       +
             description = lib.mdDoc "Extra config options for SnapRAID.";

     

       94
       94
        
             type = lines;

     

       95
       95
        
           };

     

       96
       96
        
         };

+1 -1

nixos/modules/tasks/swraid.nix

···

       10
       10
        
           };

     

       11
       11
        
       

     

       12
       12
        
           mdadmConf = lib.mkOption {

     

       13
       13
       -
             description = "Contents of <filename>/etc/mdadm.conf</filename> in initrd.";

     

       13
       13
       +
             description = lib.mdDoc "Contents of {file}`/etc/mdadm.conf` in initrd.";

     

       14
       14
        
             type = lib.types.lines;

     

       15
       15
        
             default = "";

     

       16
       16
        
           };

+6 -6

nixos/modules/virtualisation/anbox.nix

···

       10
       10
        
           address = mkOption {

     

       11
       11
        
             default = addr;

     

       12
       12
        
             type = types.str;

     

       13
       13
       -
             description = ''

     

       13
       13
       +
             description = lib.mdDoc ''

     

       14
       14
        
               IPv${toString v} ${name} address.

     

       15
       15
        
             '';

     

       16
       16
        
           };

     
···

       18
       18
        
           prefixLength = mkOption {

     

       19
       19
        
             default = pref;

     

       20
       20
        
             type = types.addCheck types.int (n: n >= 0 && n <= (if v == 4 then 32 else 128));

     

       21
       21
       -
             description = ''

     

       21
       21
       +
             description = lib.mdDoc ''

     

       22
       22
        
               Subnet mask of the ${name} address, specified as the number of

     

       23
       23
       -
               bits in the prefix (<literal>${if v == 4 then "24" else "64"}</literal>).

     

       23
       23
       +
               bits in the prefix (`${if v == 4 then "24" else "64"}`).

     

       24
       24
        
             '';

     

       25
       25
        
           };

     

       26
       26
        
         };

     
···

       37
       37
        
             default = pkgs.anbox.image;

     

       38
       38
        
             defaultText = literalExpression "pkgs.anbox.image";

     

       39
       39
        
             type = types.package;

     

       40
       40
       -
             description = ''

     

       40
       40
       +
             description = lib.mdDoc ''

     

       41
       41
        
               Base android image for Anbox.

     

       42
       42
        
             '';

     

       43
       43
        
           };

     
···

       45
       45
        
           extraInit = mkOption {

     

       46
       46
        
             type = types.lines;

     

       47
       47
        
             default = "";

     

       48
       48
       -
             description = ''

     

       48
       48
       +
             description = lib.mdDoc ''

     

       49
       49
        
               Extra shell commands to be run inside the container image during init.

     

       50
       50
        
             '';

     

       51
       51
        
           };

     
···

       57
       57
        
             dns = mkOption {

     

       58
       58
        
               default = "1.1.1.1";

     

       59
       59
        
               type = types.str;

     

       60
       60
       -
               description = ''

     

       60
       60
       +
               description = lib.mdDoc ''

     

       61
       61
        
                 Container DNS server.

     

       62
       62
        
               '';

     

       63
       63
        
             };

+4 -4

nixos/modules/virtualisation/build-vm.nix

···

       25
       25
        
         options = {

     

       26
       26
        
       

     

       27
       27
        
           virtualisation.vmVariant = mkOption {

     

       28
       28
       -
             description = ''

     

       29
       29
       -
               Machine configuration to be added for the vm script produced by <literal>nixos-rebuild build-vm</literal>.

     

       28
       28
       +
             description = lib.mdDoc ''

     

       29
       29
       +
               Machine configuration to be added for the vm script produced by `nixos-rebuild build-vm`.

     

       30
       30
        
             '';

     

       31
       31
        
             inherit (vmVariant) type;

     

       32
       32
        
             default = {};

     
···

       34
       34
        
           };

     

       35
       35
        
       

     

       36
       36
        
           virtualisation.vmVariantWithBootLoader = mkOption {

     

       37
       37
       -
             description = ''

     

       38
       38
       -
               Machine configuration to be added for the vm script produced by <literal>nixos-rebuild build-vm-with-bootloader</literal>.

     

       37
       37
       +
             description = lib.mdDoc ''

     

       38
       38
       +
               Machine configuration to be added for the vm script produced by `nixos-rebuild build-vm-with-bootloader`.

     

       39
       39
        
             '';

     

       40
       40
        
             inherit (vmVariantWithBootLoader) type;

     

       41
       41
        
             default = {};

+10 -10

nixos/modules/virtualisation/containers.nix

···

       31
       31
        
             mkOption {

     

       32
       32
        
               type = types.bool;

     

       33
       33
        
               default = false;

     

       34
       34
       -
               description = ''

     

       34
       34
       +
               description = lib.mdDoc ''

     

       35
       35
        
                 This option enables the common /etc/containers configuration module.

     

       36
       36
        
               '';

     

       37
       37
        
             };

     
···

       39
       39
        
           ociSeccompBpfHook.enable = mkOption {

     

       40
       40
        
             type = types.bool;

     

       41
       41
        
             default = false;

     

       42
       42
       -
             description = "Enable the OCI seccomp BPF hook";

     

       42
       42
       +
             description = lib.mdDoc "Enable the OCI seccomp BPF hook";

     

       43
       43
        
           };

     

       44
       44
        
       

     

       45
       45
        
           containersConf.settings = mkOption {

     

       46
       46
        
             type = toml.type;

     

       47
       47
        
             default = { };

     

       48
       48
       -
             description = "containers.conf configuration";

     

       48
       48
       +
             description = lib.mdDoc "containers.conf configuration";

     

       49
       49
        
           };

     

       50
       50
        
       

     

       51
       51
        
           containersConf.cniPlugins = mkOption {

     
···

       60
       60
        
                 pkgs.cniPlugins.dnsname

     

       61
       61
        
               ]

     

       62
       62
        
             '';

     

       63
       63
       -
             description = ''

     

       63
       63
       +
             description = lib.mdDoc ''

     

       64
       64
        
               CNI plugins to install on the system.

     

       65
       65
        
             '';

     

       66
       66
        
           };

     
···

       74
       74
        
                 runroot = "/run/containers/storage";

     

       75
       75
        
               };

     

       76
       76
        
             };

     

       77
       77
       -
             description = "storage.conf configuration";

     

       77
       77
       +
             description = lib.mdDoc "storage.conf configuration";

     

       78
       78
        
           };

     

       79
       79
        
       

     

       80
       80
        
           registries = {

     

       81
       81
        
             search = mkOption {

     

       82
       82
        
               type = types.listOf types.str;

     

       83
       83
        
               default = [ "docker.io" "quay.io" ];

     

       84
       84
       -
               description = ''

     

       84
       84
       +
               description = lib.mdDoc ''

     

       85
       85
        
                 List of repositories to search.

     

       86
       86
        
               '';

     

       87
       87
        
             };

     
···

       89
       89
        
             insecure = mkOption {

     

       90
       90
        
               default = [];

     

       91
       91
        
               type = types.listOf types.str;

     

       92
       92
       -
               description = ''

     

       92
       92
       +
               description = lib.mdDoc ''

     

       93
       93
        
                 List of insecure repositories.

     

       94
       94
        
               '';

     

       95
       95
        
             };

     
···

       97
       97
        
             block = mkOption {

     

       98
       98
        
               default = [];

     

       99
       99
        
               type = types.listOf types.str;

     

       100
       100
       -
               description = ''

     

       100
       100
       +
               description = lib.mdDoc ''

     

       101
       101
        
                 List of blocked repositories.

     

       102
       102
        
               '';

     

       103
       103
        
             };

     
···

       116
       116
        
                 };

     

       117
       117
        
               }

     

       118
       118
        
             '';

     

       119
       119
       -
             description = ''

     

       119
       119
       +
             description = lib.mdDoc ''

     

       120
       120
        
               Signature verification policy file.

     

       121
       121
        
               If this option is empty the default policy file from

     

       122
       122
       -
               <literal>skopeo</literal> will be used.

     

       122
       122
       +
               `skopeo` will be used.

     

       123
       123
        
             '';

     

       124
       124
        
           };

     

       125
       125

+6 -6

nixos/modules/virtualisation/digital-ocean-image.nix

···

       13
       13
        
             type = with types; either (enum [ "auto" ]) int;

     

       14
       14
        
             default = "auto";

     

       15
       15
        
             example = 4096;

     

       16
       16
       -
             description = ''

     

       16
       16
       +
             description = lib.mdDoc ''

     

       17
       17
        
               Size of disk image. Unit is MB.

     

       18
       18
        
             '';

     

       19
       19
        
           };

     
···

       21
       21
        
           virtualisation.digitalOceanImage.configFile = mkOption {

     

       22
       22
        
             type = with types; nullOr path;

     

       23
       23
        
             default = null;

     

       24
       24
       -
             description = ''

     

       24
       24
       +
             description = lib.mdDoc ''

     

       25
       25
        
               A path to a configuration file which will be placed at

     

       26
       26
       -
               <literal>/etc/nixos/configuration.nix</literal> and be used when switching

     

       27
       27
       -
               to a new configuration. If set to <literal>null</literal>, a default

     

       26
       26
       +
               `/etc/nixos/configuration.nix` and be used when switching

     

       27
       27
       +
               to a new configuration. If set to `null`, a default

     

       28
       28
        
               configuration is used that imports

     

       29
       29
       -
               <literal>(modulesPath + "/virtualisation/digital-ocean-config.nix")</literal>.

     

       29
       29
       +
               `(modulesPath + "/virtualisation/digital-ocean-config.nix")`.

     

       30
       30
        
             '';

     

       31
       31
        
           };

     

       32
       32
        
       

     
···

       34
       34
        
             type = types.enum [ "gzip" "bzip2" ];

     

       35
       35
        
             default = "gzip";

     

       36
       36
        
             example = "bzip2";

     

       37
       37
       -
             description = ''

     

       37
       37
       +
             description = lib.mdDoc ''

     

       38
       38
        
               Disk image compression method. Choose bzip2 to generate smaller images that

     

       39
       39
        
               take longer to generate but will consume less metered storage space on your

     

       40
       40
        
               Digital Ocean account.

+4 -4

nixos/modules/virtualisation/digital-ocean-init.nix

···

       15
       15
        
           type = types.bool;

     

       16
       16
        
           default = true;

     

       17
       17
        
           example = true;

     

       18
       18
       -
           description = "Whether to reconfigure the system from Digital Ocean user data";

     

       18
       18
       +
           description = lib.mdDoc "Whether to reconfigure the system from Digital Ocean user data";

     

       19
       19
        
         };

     

       20
       20
        
         options.virtualisation.digitalOcean.defaultConfigFile = mkOption {

     

       21
       21
        
           type = types.path;

     

       22
       22
        
           default = defaultConfigFile;

     

       23
       23
        
           defaultText = literalDocBook ''

     

       24
       24
        
             The default configuration imports user-data if applicable and

     

       25
       25
       -
             <literal>(modulesPath + "/virtualisation/digital-ocean-config.nix")</literal>.

     

       25
       25
       +
             `(modulesPath + "/virtualisation/digital-ocean-config.nix")`.

     

       26
       26
        
           '';

     

       27
       27
       -
           description = ''

     

       27
       27
       +
           description = lib.mdDoc ''

     

       28
       28
        
             A path to a configuration file which will be placed at

     

       29
       29
       -
             <literal>/etc/nixos/configuration.nix</literal> and be used when switching to

     

       29
       29
       +
             `/etc/nixos/configuration.nix` and be used when switching to

     

       30
       30
        
             a new configuration.

     

       31
       31
        
           '';

     

       32
       32
        
         };

+6 -6

nixos/modules/virtualisation/docker-rootless.nix

···

       18
       18
        
           enable = mkOption {

     

       19
       19
        
             type = types.bool;

     

       20
       20
        
             default = false;

     

       21
       21
       -
             description = ''

     

       21
       21
       +
             description = lib.mdDoc ''

     

       22
       22
        
               This option enables docker in a rootless mode, a daemon that manages

     

       23
       23
        
               linux containers. To interact with the daemon, one needs to set

     

       24
       24
       -
               <command>DOCKER_HOST=unix://$XDG_RUNTIME_DIR/docker.sock</command>.

     

       24
       24
       +
               {command}`DOCKER_HOST=unix://$XDG_RUNTIME_DIR/docker.sock`.

     

       25
       25
        
             '';

     

       26
       26
        
           };

     

       27
       27
        
       

     

       28
       28
        
           setSocketVariable = mkOption {

     

       29
       29
        
             type = types.bool;

     

       30
       30
        
             default = false;

     

       31
       31
       -
             description = ''

     

       32
       32
       -
               Point <command>DOCKER_HOST</command> to rootless Docker instance for

     

       31
       31
       +
             description = lib.mdDoc ''

     

       32
       32
       +
               Point {command}`DOCKER_HOST` to rootless Docker instance for

     

       33
       33
        
               normal users by default.

     

       34
       34
        
             '';

     

       35
       35
        
           };

     
···

       41
       41
        
               ipv6 = true;

     

       42
       42
        
               "fixed-cidr-v6" = "fd00::/80";

     

       43
       43
        
             };

     

       44
       44
       -
             description = ''

     

       44
       44
       +
             description = lib.mdDoc ''

     

       45
       45
        
               Configuration for docker daemon. The attributes are serialized to JSON used as daemon.conf.

     

       46
       46
        
               See https://docs.docker.com/engine/reference/commandline/dockerd/#daemon-configuration-file

     

       47
       47
        
             '';

     
···

       51
       51
        
             default = pkgs.docker;

     

       52
       52
        
             defaultText = literalExpression "pkgs.docker";

     

       53
       53
        
             type = types.package;

     

       54
       54
       -
             description = ''

     

       54
       54
       +
             description = lib.mdDoc ''

     

       55
       55
        
               Docker package to be used in the module.

     

       56
       56
        
             '';

     

       57
       57
        
           };

+4 -4

nixos/modules/virtualisation/openvswitch.nix

···

       13
       13
        
           enable = mkOption {

     

       14
       14
        
             type = types.bool;

     

       15
       15
        
             default = false;

     

       16
       16
       -
             description = ''

     

       16
       16
       +
             description = lib.mdDoc ''

     

       17
       17
        
               Whether to enable Open vSwitch. A configuration daemon (ovs-server)

     

       18
       18
        
               will be started.

     

       19
       19
        
               '';

     
···

       22
       22
        
           resetOnStart = mkOption {

     

       23
       23
        
             type = types.bool;

     

       24
       24
        
             default = false;

     

       25
       25
       -
             description = ''

     

       25
       25
       +
             description = lib.mdDoc ''

     

       26
       26
        
               Whether to reset the Open vSwitch configuration database to a default

     

       27
       27
       -
               configuration on every start of the systemd <literal>ovsdb.service</literal>.

     

       27
       27
       +
               configuration on every start of the systemd `ovsdb.service`.

     

       28
       28
        
               '';

     

       29
       29
        
           };

     

       30
       30
        
       

     
···

       32
       32
        
             type = types.package;

     

       33
       33
        
             default = pkgs.openvswitch;

     

       34
       34
        
             defaultText = literalExpression "pkgs.openvswitch";

     

       35
       35
       -
             description = ''

     

       35
       35
       +
             description = lib.mdDoc ''

     

       36
       36
        
               Open vSwitch package to use.

     

       37
       37
        
             '';

     

       38
       38
        
           };

+14 -14

nixos/modules/virtualisation/virtualbox-image.nix

···

       14
       14
        
               type = with types; either (enum [ "auto" ]) int;

     

       15
       15
        
               default = "auto";

     

       16
       16
        
               example = 50 * 1024;

     

       17
       17
       -
               description = ''

     

       17
       17
       +
               description = lib.mdDoc ''

     

       18
       18
        
                 The size of the VirtualBox base image in MiB.

     

       19
       19
        
               '';

     

       20
       20
        
             };

     

       21
       21
        
             baseImageFreeSpace = mkOption {

     

       22
       22
        
               type = with types; int;

     

       23
       23
        
               default = 30 * 1024;

     

       24
       24
       -
               description = ''

     

       24
       24
       +
               description = lib.mdDoc ''

     

       25
       25
        
                 Free space in the VirtualBox base image in MiB.

     

       26
       26
        
               '';

     

       27
       27
        
             };

     

       28
       28
        
             memorySize = mkOption {

     

       29
       29
        
               type = types.int;

     

       30
       30
        
               default = 1536;

     

       31
       31
       -
               description = ''

     

       31
       31
       +
               description = lib.mdDoc ''

     

       32
       32
        
                 The amount of RAM the VirtualBox appliance can use in MiB.

     

       33
       33
        
               '';

     

       34
       34
        
             };

     

       35
       35
        
             vmDerivationName = mkOption {

     

       36
       36
        
               type = types.str;

     

       37
       37
        
               default = "nixos-ova-${config.system.nixos.label}-${pkgs.stdenv.hostPlatform.system}";

     

       38
       38
       -
               description = ''

     

       38
       38
       +
               description = lib.mdDoc ''

     

       39
       39
        
                 The name of the derivation for the VirtualBox appliance.

     

       40
       40
        
               '';

     

       41
       41
        
             };

     

       42
       42
        
             vmName = mkOption {

     

       43
       43
        
               type = types.str;

     

       44
       44
        
               default = "NixOS ${config.system.nixos.label} (${pkgs.stdenv.hostPlatform.system})";

     

       45
       45
       -
               description = ''

     

       45
       45
       +
               description = lib.mdDoc ''

     

       46
       46
        
                 The name of the VirtualBox appliance.

     

       47
       47
        
               '';

     

       48
       48
        
             };

     

       49
       49
        
             vmFileName = mkOption {

     

       50
       50
        
               type = types.str;

     

       51
       51
        
               default = "nixos-${config.system.nixos.label}-${pkgs.stdenv.hostPlatform.system}.ova";

     

       52
       52
       -
               description = ''

     

       52
       52
       +
               description = lib.mdDoc ''

     

       53
       53
        
                 The file name of the VirtualBox appliance.

     

       54
       54
        
               '';

     

       55
       55
        
             };

     
···

       60
       60
        
                 rtcuseutc = "on";

     

       61
       61
        
                 usb = "off";

     

       62
       62
        
               };

     

       63
       63
       -
               description = ''

     

       63
       63
       +
               description = lib.mdDoc ''

     

       64
       64
        
                 Parameters passed to the Virtualbox appliance.

     

       65
       65
        
       

     

       66
       66
       -
                 Run <literal>VBoxManage modifyvm --help</literal> to see more options.

     

       66
       66
       +
                 Run `VBoxManage modifyvm --help` to see more options.

     

       67
       67
        
               '';

     

       68
       68
        
             };

     

       69
       69
        
             exportParams = mkOption {

     
···

       72
       72
        
                 "--vsys" "0" "--vendor" "ACME Inc."

     

       73
       73
        
               ];

     

       74
       74
        
               default = [];

     

       75
       75
       -
               description = ''

     

       75
       75
       +
               description = lib.mdDoc ''

     

       76
       76
        
                 Parameters passed to the Virtualbox export command.

     

       77
       77
        
       

     

       78
       78
       -
                 Run <literal>VBoxManage export --help</literal> to see more options.

     

       78
       78
       +
                 Run `VBoxManage export --help` to see more options.

     

       79
       79
        
               '';

     

       80
       80
        
             };

     

       81
       81
        
             extraDisk = mkOption {

     

       82
       82
       -
               description = ''

     

       82
       82
       +
               description = lib.mdDoc ''

     

       83
       83
        
                 Optional extra disk/hdd configuration.

     

       84
       84
        
                 The disk will be an 'ext4' partition on a separate VMDK file.

     

       85
       85
        
               '';

     
···

       93
       93
        
                 options = {

     

       94
       94
        
                   size = mkOption {

     

       95
       95
        
                     type = types.int;

     

       96
       96
       -
                     description = "Size in MiB";

     

       96
       96
       +
                     description = lib.mdDoc "Size in MiB";

     

       97
       97
        
                   };

     

       98
       98
        
                   label = mkOption {

     

       99
       99
        
                     type = types.str;

     

       100
       100
        
                     default = "vm-extra-storage";

     

       101
       101
       -
                     description = "Label for the disk partition";

     

       101
       101
       +
                     description = lib.mdDoc "Label for the disk partition";

     

       102
       102
        
                   };

     

       103
       103
        
                   mountPoint = mkOption {

     

       104
       104
        
                     type = types.str;

     

       105
       105
       -
                     description = "Path where to mount this disk.";

     

       105
       105
       +
                     description = lib.mdDoc "Path where to mount this disk.";

     

       106
       106
        
                   };

     

       107
       107
        
                 };

     

       108
       108
        
               });

+12 -12

nixos/modules/virtualisation/xen-dom0.nix

···

       37
       37
        
             type = types.package;

     

       38
       38
        
             defaultText = literalExpression "pkgs.xen";

     

       39
       39
        
             example = literalExpression "pkgs.xen-light";

     

       40
       40
       -
             description = ''

     

       40
       40
       +
             description = lib.mdDoc ''

     

       41
       41
        
               The package used for Xen binary.

     

       42
       42
        
             '';

     

       43
       43
        
             relatedPackages = [ "xen" "xen-light" ];

     
···

       47
       47
        
             type = types.package;

     

       48
       48
        
             defaultText = literalExpression "pkgs.xen";

     

       49
       49
        
             example = literalExpression "pkgs.qemu_xen-light";

     

       50
       50
       -
             description = ''

     

       50
       50
       +
             description = lib.mdDoc ''

     

       51
       51
        
               The package with qemu binaries for dom0 qemu and xendomains.

     

       52
       52
        
             '';

     

       53
       53
        
             relatedPackages = [ "xen"

     
···

       59
       59
        
             mkOption {

     

       60
       60
        
               default = [];

     

       61
       61
        
               type = types.listOf types.str;

     

       62
       62
       -
               description =

     

       62
       62
       +
               description = lib.mdDoc

     

       63
       63
        
                 ''

     

       64
       64
        
                   Parameters passed to the Xen hypervisor at boot time.

     

       65
       65
        
                 '';

     
···

       70
       70
        
               default = 0;

     

       71
       71
        
               example = 512;

     

       72
       72
        
               type = types.addCheck types.int (n: n >= 0);

     

       73
       73
       -
               description =

     

       73
       73
       +
               description = lib.mdDoc

     

       74
       74
        
                 ''

     

       75
       75
        
                   Amount of memory (in MiB) allocated to Domain 0 on boot.

     

       76
       76
        
                   If set to 0, all memory is assigned to Domain 0.

     
···

       81
       81
        
               name = mkOption {

     

       82
       82
        
                 default = "xenbr0";

     

       83
       83
        
                 type = types.str;

     

       84
       84
       -
                 description = ''

     

       84
       84
       +
                 description = lib.mdDoc ''

     

       85
       85
        
                     Name of bridge the Xen domUs connect to.

     

       86
       86
        
                   '';

     

       87
       87
        
               };

     
···

       89
       89
        
               address = mkOption {

     

       90
       90
        
                 type = types.str;

     

       91
       91
        
                 default = "172.16.0.1";

     

       92
       92
       -
                 description = ''

     

       92
       92
       +
                 description = lib.mdDoc ''

     

       93
       93
        
                   IPv4 address of the bridge.

     

       94
       94
        
                 '';

     

       95
       95
        
               };

     
···

       97
       97
        
               prefixLength = mkOption {

     

       98
       98
        
                 type = types.addCheck types.int (n: n >= 0 && n <= 32);

     

       99
       99
        
                 default = 16;

     

       100
       100
       -
                 description = ''

     

       100
       100
       +
                 description = lib.mdDoc ''

     

       101
       101
        
                   Subnet mask of the bridge interface, specified as the number of

     

       102
       102
       -
                   bits in the prefix (<literal>24</literal>).

     

       102
       102
       +
                   bits in the prefix (`24`).

     

       103
       103
        
                   A DHCP server will provide IP addresses for the whole, remaining

     

       104
       104
        
                   subnet.

     

       105
       105
        
                 '';

     
···

       108
       108
        
               forwardDns = mkOption {

     

       109
       109
        
                 type = types.bool;

     

       110
       110
        
                 default = false;

     

       111
       111
       -
                 description = ''

     

       112
       112
       -
                   If set to <literal>true</literal>, the DNS queries from the

     

       111
       111
       +
                 description = lib.mdDoc ''

     

       112
       112
       +
                   If set to `true`, the DNS queries from the

     

       113
       113
        
                   hosts connected to the bridge will be forwarded to the DNS

     

       114
       114
        
                   servers specified in /etc/resolv.conf .

     

       115
       115
        
                   '';

     
···

       120
       120
        
           virtualisation.xen.stored =

     

       121
       121
        
             mkOption {

     

       122
       122
        
               type = types.path;

     

       123
       123
       -
               description =

     

       123
       123
       +
               description = lib.mdDoc

     

       124
       124
        
                 ''

     

       125
       125
        
                   Xen Store daemon to use. Defaults to oxenstored of the xen package.

     

       126
       126
        
                 '';

     
···

       130
       130
        
               extraConfig = mkOption {

     

       131
       131
        
                 type = types.lines;

     

       132
       132
        
                 default = "";

     

       133
       133
       -
                 description =

     

       133
       133
       +
                 description = lib.mdDoc

     

       134
       134
        
                   ''

     

       135
       135
        
                     Options defined here will override the defaults for xendomains.

     

       136
       136
        
                     The default options can be seen in the file included from