commit ef176dcf7e76c3639571d7c6051246c8fbadf12a · pyrox.dev/nixpkgs

+4 -4

nixos/lib/systemd-types.nix

···

       37
       37
        
       

     

       38
       38
        
         initrdContents = types.attrsOf (types.submodule ({ config, options, name, ... }: {

     

       39
       39
        
           options = {

     

       40
       40
       -
             enable = mkEnableOption "copying of this file and symlinking it" // { default = true; };

     

       40
       40
       +
             enable = mkEnableOption (lib.mdDoc "copying of this file and symlinking it") // { default = true; };

     

       41
       41
        
       

     

       42
       42
        
             target = mkOption {

     

       43
       43
        
               type = types.path;

     

       44
       44
       -
               description = ''

     

       44
       44
       +
               description = lib.mdDoc ''

     

       45
       45
        
                 Path of the symlink.

     

       46
       46
        
               '';

     

       47
       47
        
               default = name;

     
···

       50
       50
        
             text = mkOption {

     

       51
       51
        
               default = null;

     

       52
       52
        
               type = types.nullOr types.lines;

     

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

     

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

     

       54
       54
        
             };

     

       55
       55
        
       

     

       56
       56
        
             source = mkOption {

     

       57
       57
        
               type = types.path;

     

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

     

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

     

       59
       59
        
             };

     

       60
       60
        
           };

     

       61
       61

+90 -90

nixos/lib/systemd-unit-options.nix

···

       37
       37
        
           enable = mkOption {

     

       38
       38
        
             default = true;

     

       39
       39
        
             type = types.bool;

     

       40
       40
       -
             description = ''

     

       40
       40
       +
             description = lib.mdDoc ''

     

       41
       41
        
               If set to false, this unit will be a symlink to

     

       42
       42
        
               /dev/null. This is primarily useful to prevent specific

     

       43
       43
        
               template instances

     

       44
       44
       -
               (e.g. <literal>serial-getty@ttyS0</literal>) from being

     

       45
       45
       -
               started. Note that <literal>enable=true</literal> does not

     

       44
       44
       +
               (e.g. `serial-getty@ttyS0`) from being

     

       45
       45
       +
               started. Note that `enable=true` does not

     

       46
       46
        
               make a unit start by default at boot; if you want that, see

     

       47
       47
       -
               <literal>wantedBy</literal>.

     

       47
       47
       +
               `wantedBy`.

     

       48
       48
        
             '';

     

       49
       49
        
           };

     

       50
       50
        
       

     

       51
       51
        
           requiredBy = mkOption {

     

       52
       52
        
             default = [];

     

       53
       53
        
             type = types.listOf unitNameType;

     

       54
       54
       -
             description = ''

     

       54
       54
       +
             description = lib.mdDoc ''

     

       55
       55
        
               Units that require (i.e. depend on and need to go down with)

     

       56
       56
       -
               this unit. The discussion under <literal>wantedBy</literal>

     

       57
       57
       -
               applies here as well: inverse <literal>.requires</literal>

     

       56
       56
       +
               this unit. The discussion under `wantedBy`

     

       57
       57
       +
               applies here as well: inverse `.requires`

     

       58
       58
        
               symlinks are established.

     

       59
       59
        
             '';

     

       60
       60
        
           };

     
···

       62
       62
        
           wantedBy = mkOption {

     

       63
       63
        
             default = [];

     

       64
       64
        
             type = types.listOf unitNameType;

     

       65
       65
       -
             description = ''

     

       65
       65
       +
             description = lib.mdDoc ''

     

       66
       66
        
               Units that want (i.e. depend on) this unit. The standard way

     

       67
       67
        
               to make a unit start by default at boot is to set this option

     

       68
       68
       -
               to <literal>[ "multi-user.target" ]</literal>. That's despite

     

       68
       68
       +
               to `[ "multi-user.target" ]`. That's despite

     

       69
       69
        
               the fact that the systemd.unit(5) manpage says this option

     

       70
       70
       -
               goes in the <literal>[Install]</literal> section that controls

     

       71
       71
       -
               the behaviour of <literal>systemctl enable</literal>. Since

     

       70
       70
       +
               goes in the `[Install]` section that controls

     

       71
       71
       +
               the behaviour of `systemctl enable`. Since

     

       72
       72
        
               such a process is stateful and thus contrary to the design of

     

       73
       73
        
               NixOS, setting this option instead causes the equivalent

     

       74
       74
       -
               inverse <literal>.wants</literal> symlink to be present,

     

       74
       74
       +
               inverse `.wants` symlink to be present,

     

       75
       75
        
               establishing the same desired relationship in a stateless way.

     

       76
       76
        
             '';

     

       77
       77
        
           };

     
···

       79
       79
        
           aliases = mkOption {

     

       80
       80
        
             default = [];

     

       81
       81
        
             type = types.listOf unitNameType;

     

       82
       82
       -
             description = "Aliases of that unit.";

     

       82
       82
       +
             description = lib.mdDoc "Aliases of that unit.";

     

       83
       83
        
           };

     

       84
       84
        
       

     

       85
       85
        
         };

     
···

       89
       89
        
           text = mkOption {

     

       90
       90
        
             type = types.nullOr types.str;

     

       91
       91
        
             default = null;

     

       92
       92
       -
             description = "Text of this systemd unit.";

     

       92
       92
       +
             description = lib.mdDoc "Text of this systemd unit.";

     

       93
       93
        
           };

     

       94
       94
        
       

     

       95
       95
        
           unit = mkOption {

     
···

       105
       105
        
             description = mkOption {

     

       106
       106
        
               default = "";

     

       107
       107
        
               type = types.singleLineStr;

     

       108
       108
       -
               description = "Description of this unit used in systemd messages and progress indicators.";

     

       108
       108
       +
               description = lib.mdDoc "Description of this unit used in systemd messages and progress indicators.";

     

       109
       109
        
             };

     

       110
       110
        
       

     

       111
       111
        
             documentation = mkOption {

     

       112
       112
        
               default = [];

     

       113
       113
        
               type = types.listOf types.str;

     

       114
       114
       -
               description = "A list of URIs referencing documentation for this unit or its configuration.";

     

       114
       114
       +
               description = lib.mdDoc "A list of URIs referencing documentation for this unit or its configuration.";

     

       115
       115
        
             };

     

       116
       116
        
       

     

       117
       117
        
             requires = mkOption {

     

       118
       118
        
               default = [];

     

       119
       119
        
               type = types.listOf unitNameType;

     

       120
       120
       -
               description = ''

     

       120
       120
       +
               description = lib.mdDoc ''

     

       121
       121
        
                 Start the specified units when this unit is started, and stop

     

       122
       122
        
                 this unit when the specified units are stopped or fail.

     

       123
       123
        
               '';

     
···

       126
       126
        
             wants = mkOption {

     

       127
       127
        
               default = [];

     

       128
       128
        
               type = types.listOf unitNameType;

     

       129
       129
       -
               description = ''

     

       129
       129
       +
               description = lib.mdDoc ''

     

       130
       130
        
                 Start the specified units when this unit is started.

     

       131
       131
        
               '';

     

       132
       132
        
             };

     
···

       134
       134
        
             after = mkOption {

     

       135
       135
        
               default = [];

     

       136
       136
        
               type = types.listOf unitNameType;

     

       137
       137
       -
               description = ''

     

       137
       137
       +
               description = lib.mdDoc ''

     

       138
       138
        
                 If the specified units are started at the same time as

     

       139
       139
        
                 this unit, delay this unit until they have started.

     

       140
       140
        
               '';

     
···

       143
       143
        
             before = mkOption {

     

       144
       144
        
               default = [];

     

       145
       145
        
               type = types.listOf unitNameType;

     

       146
       146
       -
               description = ''

     

       146
       146
       +
               description = lib.mdDoc ''

     

       147
       147
        
                 If the specified units are started at the same time as

     

       148
       148
        
                 this unit, delay them until this unit has started.

     

       149
       149
        
               '';

     
···

       152
       152
        
             bindsTo = mkOption {

     

       153
       153
        
               default = [];

     

       154
       154
        
               type = types.listOf unitNameType;

     

       155
       155
       -
               description = ''

     

       155
       155
       +
               description = lib.mdDoc ''

     

       156
       156
        
                 Like ‘requires’, but in addition, if the specified units

     

       157
       157
        
                 unexpectedly disappear, this unit will be stopped as well.

     

       158
       158
        
               '';

     
···

       161
       161
        
             partOf = mkOption {

     

       162
       162
        
               default = [];

     

       163
       163
        
               type = types.listOf unitNameType;

     

       164
       164
       -
               description = ''

     

       164
       164
       +
               description = lib.mdDoc ''

     

       165
       165
        
                 If the specified units are stopped or restarted, then this

     

       166
       166
        
                 unit is stopped or restarted as well.

     

       167
       167
        
               '';

     
···

       170
       170
        
             conflicts = mkOption {

     

       171
       171
        
               default = [];

     

       172
       172
        
               type = types.listOf unitNameType;

     

       173
       173
       -
               description = ''

     

       173
       173
       +
               description = lib.mdDoc ''

     

       174
       174
        
                 If the specified units are started, then this unit is stopped

     

       175
       175
        
                 and vice versa.

     

       176
       176
        
               '';

     
···

       179
       179
        
             requisite = mkOption {

     

       180
       180
        
               default = [];

     

       181
       181
        
               type = types.listOf unitNameType;

     

       182
       182
       -
               description = ''

     

       182
       182
       +
               description = lib.mdDoc ''

     

       183
       183
        
                 Similar to requires. However if the units listed are not started,

     

       184
       184
        
                 they will not be started and the transaction will fail.

     

       185
       185
        
               '';

     
···

       189
       189
        
               default = {};

     

       190
       190
        
               example = { RequiresMountsFor = "/data"; };

     

       191
       191
        
               type = types.attrsOf unitOption;

     

       192
       192
       -
               description = ''

     

       192
       192
       +
               description = lib.mdDoc ''

     

       193
       193
        
                 Each attribute in this set specifies an option in the

     

       194
       194
       -
                 <literal>[Unit]</literal> section of the unit.  See

     

       195
       195
       -
                 <citerefentry><refentrytitle>systemd.unit</refentrytitle><manvolnum>5</manvolnum></citerefentry> for details.

     

       194
       194
       +
                 `[Unit]` section of the unit.  See

     

       195
       195
       +
                 {manpage}`systemd.unit(5)` for details.

     

       196
       196
        
               '';

     

       197
       197
        
             };

     

       198
       198
        
       

     

       199
       199
        
             onFailure = mkOption {

     

       200
       200
        
               default = [];

     

       201
       201
        
               type = types.listOf unitNameType;

     

       202
       202
       -
               description = ''

     

       202
       202
       +
               description = lib.mdDoc ''

     

       203
       203
        
                 A list of one or more units that are activated when

     

       204
       204
        
                 this unit enters the "failed" state.

     

       205
       205
        
               '';

     
···

       208
       208
        
             onSuccess = mkOption {

     

       209
       209
        
               default = [];

     

       210
       210
        
               type = types.listOf unitNameType;

     

       211
       211
       -
               description = ''

     

       211
       211
       +
               description = lib.mdDoc ''

     

       212
       212
        
                 A list of one or more units that are activated when

     

       213
       213
        
                 this unit enters the "inactive" state.

     

       214
       214
        
               '';

     
···

       216
       216
        
       

     

       217
       217
        
             startLimitBurst = mkOption {

     

       218
       218
        
                type = types.int;

     

       219
       219
       -
                description = ''

     

       219
       219
       +
                description = lib.mdDoc ''

     

       220
       220
        
                  Configure unit start rate limiting. Units which are started

     

       221
       221
        
                  more than startLimitBurst times within an interval time

     

       222
       222
        
                  interval are not permitted to start any more.

     
···

       225
       225
        
       

     

       226
       226
        
             startLimitIntervalSec = mkOption {

     

       227
       227
        
                type = types.int;

     

       228
       228
       -
                description = ''

     

       228
       228
       +
                description = lib.mdDoc ''

     

       229
       229
        
                  Configure unit start rate limiting. Units which are started

     

       230
       230
        
                  more than startLimitBurst times within an interval time

     

       231
       231
        
                  interval are not permitted to start any more.

     
···

       244
       244
        
             restartTriggers = mkOption {

     

       245
       245
        
               default = [];

     

       246
       246
        
               type = types.listOf types.unspecified;

     

       247
       247
       -
               description = ''

     

       247
       247
       +
               description = lib.mdDoc ''

     

       248
       248
        
                 An arbitrary list of items such as derivations.  If any item

     

       249
       249
        
                 in the list changes between reconfigurations, the service will

     

       250
       250
        
                 be restarted.

     
···

       254
       254
        
             reloadTriggers = mkOption {

     

       255
       255
        
               default = [];

     

       256
       256
        
               type = types.listOf unitOption;

     

       257
       257
       -
               description = ''

     

       257
       257
       +
               description = lib.mdDoc ''

     

       258
       258
        
                 An arbitrary list of items such as derivations.  If any item

     

       259
       259
        
                 in the list changes between reconfigurations, the service will

     

       260
       260
        
                 be reloaded.  If anything but a reload trigger changes in the

     
···

       272
       272
        
               default = {};

     

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

     

       274
       274
        
               example = { PATH = "/foo/bar/bin"; LANG = "nl_NL.UTF-8"; };

     

       275
       275
       -
               description = "Environment variables passed to the service's processes.";

     

       275
       275
       +
               description = lib.mdDoc "Environment variables passed to the service's processes.";

     

       276
       276
        
             };

     

       277
       277
        
       

     

       278
       278
        
             path = mkOption {

     

       279
       279
        
               default = [];

     

       280
       280
        
               type = with types; listOf (oneOf [ package str ]);

     

       281
       281
       -
               description = ''

     

       282
       282
       -
                 Packages added to the service's <envar>PATH</envar>

     

       283
       283
       -
                 environment variable.  Both the <filename>bin</filename>

     

       284
       284
       -
                 and <filename>sbin</filename> subdirectories of each

     

       281
       281
       +
               description = lib.mdDoc ''

     

       282
       282
       +
                 Packages added to the service's {env}`PATH`

     

       283
       283
       +
                 environment variable.  Both the {file}`bin`

     

       284
       284
       +
                 and {file}`sbin` subdirectories of each

     

       285
       285
        
                 package are added.

     

       286
       286
        
               '';

     

       287
       287
        
             };

     
···

       292
       292
        
                 { RestartSec = 5;

     

       293
       293
        
                 };

     

       294
       294
        
               type = types.addCheck (types.attrsOf unitOption) checkService;

     

       295
       295
       -
               description = ''

     

       295
       295
       +
               description = lib.mdDoc ''

     

       296
       296
        
                 Each attribute in this set specifies an option in the

     

       297
       297
       -
                 <literal>[Service]</literal> section of the unit.  See

     

       298
       298
       -
                 <citerefentry><refentrytitle>systemd.service</refentrytitle><manvolnum>5</manvolnum></citerefentry> for details.

     

       297
       297
       +
                 `[Service]` section of the unit.  See

     

       298
       298
       +
                 {manpage}`systemd.service(5)` for details.

     

       299
       299
        
               '';

     

       300
       300
        
             };

     

       301
       301
        
       

     

       302
       302
        
             script = mkOption {

     

       303
       303
        
               type = types.lines;

     

       304
       304
        
               default = "";

     

       305
       305
       -
               description = "Shell commands executed as the service's main process.";

     

       305
       305
       +
               description = lib.mdDoc "Shell commands executed as the service's main process.";

     

       306
       306
        
             };

     

       307
       307
        
       

     

       308
       308
        
             scriptArgs = mkOption {

     

       309
       309
        
               type = types.str;

     

       310
       310
        
               default = "";

     

       311
       311
       -
               description = "Arguments passed to the main process script.";

     

       311
       311
       +
               description = lib.mdDoc "Arguments passed to the main process script.";

     

       312
       312
        
             };

     

       313
       313
        
       

     

       314
       314
        
             preStart = mkOption {

     

       315
       315
        
               type = types.lines;

     

       316
       316
        
               default = "";

     

       317
       317
       -
               description = ''

     

       317
       317
       +
               description = lib.mdDoc ''

     

       318
       318
        
                 Shell commands executed before the service's main process

     

       319
       319
        
                 is started.

     

       320
       320
        
               '';

     
···

       323
       323
        
             postStart = mkOption {

     

       324
       324
        
               type = types.lines;

     

       325
       325
        
               default = "";

     

       326
       326
       -
               description = ''

     

       326
       326
       +
               description = lib.mdDoc ''

     

       327
       327
        
                 Shell commands executed after the service's main process

     

       328
       328
        
                 is started.

     

       329
       329
        
               '';

     
···

       332
       332
        
             reload = mkOption {

     

       333
       333
        
               type = types.lines;

     

       334
       334
        
               default = "";

     

       335
       335
       -
               description = ''

     

       335
       335
       +
               description = lib.mdDoc ''

     

       336
       336
        
                 Shell commands executed when the service's main process

     

       337
       337
        
                 is reloaded.

     

       338
       338
        
               '';

     
···

       341
       341
        
             preStop = mkOption {

     

       342
       342
        
               type = types.lines;

     

       343
       343
        
               default = "";

     

       344
       344
       -
               description = ''

     

       344
       344
       +
               description = lib.mdDoc ''

     

       345
       345
        
                 Shell commands executed to stop the service.

     

       346
       346
        
               '';

     

       347
       347
        
             };

     
···

       349
       349
        
             postStop = mkOption {

     

       350
       350
        
               type = types.lines;

     

       351
       351
        
               default = "";

     

       352
       352
       -
               description = ''

     

       352
       352
       +
               description = lib.mdDoc ''

     

       353
       353
        
                 Shell commands executed after the service's main process

     

       354
       354
        
                 has exited.

     

       355
       355
        
               '';

     
···

       403
       403
        
             restartIfChanged = mkOption {

     

       404
       404
        
               type = types.bool;

     

       405
       405
        
               default = true;

     

       406
       406
       -
               description = ''

     

       406
       406
       +
               description = lib.mdDoc ''

     

       407
       407
        
                 Whether the service should be restarted during a NixOS

     

       408
       408
        
                 configuration switch if its definition has changed.

     

       409
       409
        
               '';

     
···

       412
       412
        
             reloadIfChanged = mkOption {

     

       413
       413
        
               type = types.bool;

     

       414
       414
        
               default = false;

     

       415
       415
       -
               description = ''

     

       415
       415
       +
               description = lib.mdDoc ''

     

       416
       416
        
                 Whether the service should be reloaded during a NixOS

     

       417
       417
        
                 configuration switch if its definition has changed.  If

     

       418
       418
       -
                 enabled, the value of <option>restartIfChanged</option> is

     

       418
       418
       +
                 enabled, the value of {option}`restartIfChanged` is

     

       419
       419
        
                 ignored.

     

       420
       420
        
       

     

       421
       421
        
                 This option should not be used anymore in favor of

     

       422
       422
       -
                 <option>reloadTriggers</option> which allows more granular

     

       422
       422
       +
                 {option}`reloadTriggers` which allows more granular

     

       423
       423
        
                 control of when a service is reloaded and when a service

     

       424
       424
        
                 is restarted.

     

       425
       425
        
               '';

     
···

       428
       428
        
             stopIfChanged = mkOption {

     

       429
       429
        
               type = types.bool;

     

       430
       430
        
               default = true;

     

       431
       431
       -
               description = ''

     

       431
       431
       +
               description = lib.mdDoc ''

     

       432
       432
        
                 If set, a changed unit is restarted by calling

     

       433
       433
       -
                 <command>systemctl stop</command> in the old configuration,

     

       434
       434
       -
                 then <command>systemctl start</command> in the new one.

     

       433
       433
       +
                 {command}`systemctl stop` in the old configuration,

     

       434
       434
       +
                 then {command}`systemctl start` in the new one.

     

       435
       435
        
                 Otherwise, it is restarted in a single step using

     

       436
       436
       -
                 <command>systemctl restart</command> in the new configuration.

     

       436
       436
       +
                 {command}`systemctl restart` in the new configuration.

     

       437
       437
        
                 The latter is less correct because it runs the

     

       438
       438
       -
                 <literal>ExecStop</literal> commands from the new

     

       438
       438
       +
                 `ExecStop` commands from the new

     

       439
       439
        
                 configuration.

     

       440
       440
        
               '';

     

       441
       441
        
             };

     
···

       444
       444
        
               type = with types; either str (listOf str);

     

       445
       445
        
               default = [];

     

       446
       446
        
               example = "Sun 14:00:00";

     

       447
       447
       -
               description = ''

     

       447
       447
       +
               description = lib.mdDoc ''

     

       448
       448
        
                 Automatically start this unit at the given date/time, which

     

       449
       449
        
                 must be in the format described in

     

       450
       450
       -
                 <citerefentry><refentrytitle>systemd.time</refentrytitle><manvolnum>7</manvolnum></citerefentry>.  This is equivalent

     

       450
       450
       +
                 {manpage}`systemd.time(7)`.  This is equivalent

     

       451
       451
        
                 to adding a corresponding timer unit with

     

       452
       452
       -
                 <option>OnCalendar</option> set to the value given here.

     

       452
       452
       +
                 {option}`OnCalendar` set to the value given here.

     

       453
       453
        
               '';

     

       454
       454
        
               apply = v: if isList v then v else [ v ];

     

       455
       455
        
             };

     
···

       471
       471
        
               default = [];

     

       472
       472
        
               type = types.listOf types.str;

     

       473
       473
        
               example = [ "0.0.0.0:993" "/run/my-socket" ];

     

       474
       474
       -
               description = ''

     

       475
       475
       -
                 For each item in this list, a <literal>ListenStream</literal>

     

       476
       476
       -
                 option in the <literal>[Socket]</literal> section will be created.

     

       474
       474
       +
               description = lib.mdDoc ''

     

       475
       475
       +
                 For each item in this list, a `ListenStream`

     

       476
       476
       +
                 option in the `[Socket]` section will be created.

     

       477
       477
        
               '';

     

       478
       478
        
             };

     

       479
       479
        
       

     
···

       481
       481
        
               default = [];

     

       482
       482
        
               type = types.listOf types.str;

     

       483
       483
        
               example = [ "0.0.0.0:993" "/run/my-socket" ];

     

       484
       484
       -
               description = ''

     

       485
       485
       -
                 For each item in this list, a <literal>ListenDatagram</literal>

     

       486
       486
       -
                 option in the <literal>[Socket]</literal> section will be created.

     

       484
       484
       +
               description = lib.mdDoc ''

     

       485
       485
       +
                 For each item in this list, a `ListenDatagram`

     

       486
       486
       +
                 option in the `[Socket]` section will be created.

     

       487
       487
        
               '';

     

       488
       488
        
             };

     

       489
       489
        
       

     
···

       491
       491
        
               default = {};

     

       492
       492
        
               example = { ListenStream = "/run/my-socket"; };

     

       493
       493
        
               type = types.attrsOf unitOption;

     

       494
       494
       -
               description = ''

     

       494
       494
       +
               description = lib.mdDoc ''

     

       495
       495
        
                 Each attribute in this set specifies an option in the

     

       496
       496
       -
                 <literal>[Socket]</literal> section of the unit.  See

     

       497
       497
       -
                 <citerefentry><refentrytitle>systemd.socket</refentrytitle><manvolnum>5</manvolnum></citerefentry> for details.

     

       496
       496
       +
                 `[Socket]` section of the unit.  See

     

       497
       497
       +
                 {manpage}`systemd.socket(5)` for details.

     

       498
       498
        
               '';

     

       499
       499
        
             };

     

       500
       500
        
           };

     
···

       523
       523
        
               default = {};

     

       524
       524
        
               example = { OnCalendar = "Sun 14:00:00"; Unit = "foo.service"; };

     

       525
       525
        
               type = types.attrsOf unitOption;

     

       526
       526
       -
               description = ''

     

       526
       526
       +
               description = lib.mdDoc ''

     

       527
       527
        
                 Each attribute in this set specifies an option in the

     

       528
       528
       -
                 <literal>[Timer]</literal> section of the unit.  See

     

       529
       529
       -
                 <citerefentry><refentrytitle>systemd.timer</refentrytitle><manvolnum>5</manvolnum></citerefentry> and

     

       530
       530
       -
                 <citerefentry><refentrytitle>systemd.time</refentrytitle><manvolnum>7</manvolnum></citerefentry> for details.

     

       528
       528
       +
                 `[Timer]` section of the unit.  See

     

       529
       529
       +
                 {manpage}`systemd.timer(5)` and

     

       530
       530
       +
                 {manpage}`systemd.time(7)` for details.

     

       531
       531
        
               '';

     

       532
       532
        
             };

     

       533
       533
        
       

     
···

       556
       556
        
               default = {};

     

       557
       557
        
               example = { PathChanged = "/some/path"; Unit = "changedpath.service"; };

     

       558
       558
        
               type = types.attrsOf unitOption;

     

       559
       559
       -
               description = ''

     

       559
       559
       +
               description = lib.mdDoc ''

     

       560
       560
        
                 Each attribute in this set specifies an option in the

     

       561
       561
       -
                 <literal>[Path]</literal> section of the unit.  See

     

       562
       562
       -
                 <citerefentry><refentrytitle>systemd.path</refentrytitle><manvolnum>5</manvolnum></citerefentry> for details.

     

       561
       561
       +
                 `[Path]` section of the unit.  See

     

       562
       562
       +
                 {manpage}`systemd.path(5)` for details.

     

       563
       563
        
               '';

     

       564
       564
        
             };

     

       565
       565
        
       

     
···

       587
       587
        
             what = mkOption {

     

       588
       588
        
               example = "/dev/sda1";

     

       589
       589
        
               type = types.str;

     

       590
       590
       -
               description = "Absolute path of device node, file or other resource. (Mandatory)";

     

       590
       590
       +
               description = lib.mdDoc "Absolute path of device node, file or other resource. (Mandatory)";

     

       591
       591
        
             };

     

       592
       592
        
       

     

       593
       593
        
             where = mkOption {

     

       594
       594
        
               example = "/mnt";

     

       595
       595
        
               type = types.str;

     

       596
       596
       -
               description = ''

     

       596
       596
       +
               description = lib.mdDoc ''

     

       597
       597
        
                 Absolute path of a directory of the mount point.

     

       598
       598
        
                 Will be created if it doesn't exist. (Mandatory)

     

       599
       599
        
               '';

     
···

       603
       603
        
               default = "";

     

       604
       604
        
               example = "ext4";

     

       605
       605
        
               type = types.str;

     

       606
       606
       -
               description = "File system type.";

     

       606
       606
       +
               description = lib.mdDoc "File system type.";

     

       607
       607
        
             };

     

       608
       608
        
       

     

       609
       609
        
             options = mkOption {

     

       610
       610
        
               default = "";

     

       611
       611
        
               example = "noatime";

     

       612
       612
        
               type = types.commas;

     

       613
       613
       -
               description = "Options used to mount the file system.";

     

       613
       613
       +
               description = lib.mdDoc "Options used to mount the file system.";

     

       614
       614
        
             };

     

       615
       615
        
       

     

       616
       616
        
             mountConfig = mkOption {

     

       617
       617
        
               default = {};

     

       618
       618
        
               example = { DirectoryMode = "0775"; };

     

       619
       619
        
               type = types.attrsOf unitOption;

     

       620
       620
       -
               description = ''

     

       620
       620
       +
               description = lib.mdDoc ''

     

       621
       621
        
                 Each attribute in this set specifies an option in the

     

       622
       622
       -
                 <literal>[Mount]</literal> section of the unit.  See

     

       623
       623
       -
                 <citerefentry><refentrytitle>systemd.mount</refentrytitle><manvolnum>5</manvolnum></citerefentry> for details.

     

       622
       622
       +
                 `[Mount]` section of the unit.  See

     

       623
       623
       +
                 {manpage}`systemd.mount(5)` for details.

     

       624
       624
        
               '';

     

       625
       625
        
             };

     

       626
       626
        
       

     
···

       647
       647
        
             where = mkOption {

     

       648
       648
        
               example = "/mnt";

     

       649
       649
        
               type = types.str;

     

       650
       650
       -
               description = ''

     

       650
       650
       +
               description = lib.mdDoc ''

     

       651
       651
        
                 Absolute path of a directory of the mount point.

     

       652
       652
        
                 Will be created if it doesn't exist. (Mandatory)

     

       653
       653
        
               '';

     
···

       657
       657
        
               default = {};

     

       658
       658
        
               example = { DirectoryMode = "0775"; };

     

       659
       659
        
               type = types.attrsOf unitOption;

     

       660
       660
       -
               description = ''

     

       660
       660
       +
               description = lib.mdDoc ''

     

       661
       661
        
                 Each attribute in this set specifies an option in the

     

       662
       662
       -
                 <literal>[Automount]</literal> section of the unit.  See

     

       663
       663
       -
                 <citerefentry><refentrytitle>systemd.automount</refentrytitle><manvolnum>5</manvolnum></citerefentry> for details.

     

       662
       662
       +
                 `[Automount]` section of the unit.  See

     

       663
       663
       +
                 {manpage}`systemd.automount(5)` for details.

     

       664
       664
        
               '';

     

       665
       665
        
             };

     

       666
       666
        
       

     
···

       688
       688
        
               default = {};

     

       689
       689
        
               example = { MemoryMax = "2G"; };

     

       690
       690
        
               type = types.attrsOf unitOption;

     

       691
       691
       -
               description = ''

     

       691
       691
       +
               description = lib.mdDoc ''

     

       692
       692
        
                 Each attribute in this set specifies an option in the

     

       693
       693
       -
                 <literal>[Slice]</literal> section of the unit.  See

     

       694
       694
       -
                 <citerefentry><refentrytitle>systemd.slice</refentrytitle><manvolnum>5</manvolnum></citerefentry> for details.

     

       693
       693
       +
                 `[Slice]` section of the unit.  See

     

       694
       694
       +
                 {manpage}`systemd.slice(5)` for details.

     

       695
       695
        
               '';

     

       696
       696
        
             };

     

       697
       697

+3 -3

nixos/maintainers/scripts/openstack/openstack-image-zfs.nix

···

       16
       16
        
         options.openstackImage = {

     

       17
       17
        
           name = mkOption {

     

       18
       18
        
             type = types.str;

     

       19
       19
       -
             description = "The name of the generated derivation";

     

       19
       19
       +
             description = lib.mdDoc "The name of the generated derivation";

     

       20
       20
        
             default = "nixos-openstack-image-${config.system.nixos.label}-${pkgs.stdenv.hostPlatform.system}";

     

       21
       21
        
           };

     

       22
       22
        
       

     

       23
       23
        
           sizeMB = mkOption {

     

       24
       24
        
             type = types.int;

     

       25
       25
        
             default = 8192;

     

       26
       26
       -
             description = "The size in MB of the image";

     

       26
       26
       +
             description = lib.mdDoc "The size in MB of the image";

     

       27
       27
        
           };

     

       28
       28
        
       

     

       29
       29
        
           format = mkOption {

     

       30
       30
        
             type = types.enum [ "raw" "qcow2" ];

     

       31
       31
        
             default = "qcow2";

     

       32
       32
       -
             description = "The image format to output";

     

       32
       32
       +
             description = lib.mdDoc "The image format to output";

     

       33
       33
        
           };

     

       34
       34
        
         };

     

       35
       35

+1 -1

nixos/modules/config/iproute2.nix

···

       7
       7
        
       in

     

       8
       8
        
       {

     

       9
       9
        
         options.networking.iproute2 = {

     

       10
       10
       -
           enable = mkEnableOption "copy IP route configuration files";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "copy IP route configuration files");

     

       11
       11
        
           rttablesExtraConfig = mkOption {

     

       12
       12
        
             type = types.lines;

     

       13
       13
        
             default = "";

+1 -1

nixos/modules/config/krb5/default.nix

···

       78
       78
        
       

     

       79
       79
        
         options = {

     

       80
       80
        
           krb5 = {

     

       81
       81
       -
             enable = mkEnableOption "building krb5.conf, configuration file for Kerberos V";

     

       81
       81
       +
             enable = mkEnableOption (lib.mdDoc "building krb5.conf, configuration file for Kerberos V");

     

       82
       82
        
       

     

       83
       83
        
             kerberos = mkOption {

     

       84
       84
        
               type = types.package;

+1 -1

nixos/modules/config/ldap.nix

···

       59
       59
        
       

     

       60
       60
        
           users.ldap = {

     

       61
       61
        
       

     

       62
       62
       -
             enable = mkEnableOption "authentication against an LDAP server";

     

       62
       62
       +
             enable = mkEnableOption (lib.mdDoc "authentication against an LDAP server");

     

       63
       63
        
       

     

       64
       64
        
             loginPam = mkOption {

     

       65
       65
        
               type = types.bool;

+51 -51

nixos/modules/config/mysql.nix

···

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
        
           users.mysql = {

     

       11
       11
       -
             enable = mkEnableOption "Authentication against a MySQL/MariaDB database";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "Authentication against a MySQL/MariaDB database");

     

       12
       12
        
             host = mkOption {

     

       13
       13
        
               type = types.str;

     

       14
       14
        
               example = "localhost";

     

       15
       15
       -
               description = "The hostname of the MySQL/MariaDB server";

     

       15
       15
       +
               description = lib.mdDoc "The hostname of the MySQL/MariaDB server";

     

       16
       16
        
             };

     

       17
       17
        
             database = mkOption {

     

       18
       18
        
               type = types.str;

     

       19
       19
        
               example = "auth";

     

       20
       20
       -
               description = "The name of the database containing the users";

     

       20
       20
       +
               description = lib.mdDoc "The name of the database containing the users";

     

       21
       21
        
             };

     

       22
       22
        
             user = mkOption {

     

       23
       23
        
               type = types.str;

     

       24
       24
        
               example = "nss-user";

     

       25
       25
       -
               description = "The username to use when connecting to the database";

     

       25
       25
       +
               description = lib.mdDoc "The username to use when connecting to the database";

     

       26
       26
        
             };

     

       27
       27
        
             passwordFile = mkOption {

     

       28
       28
        
               type = types.path;

     

       29
       29
        
               example = "/run/secrets/mysql-auth-db-passwd";

     

       30
       30
       -
               description = "The path to the file containing the password for the user";

     

       30
       30
       +
               description = lib.mdDoc "The path to the file containing the password for the user";

     

       31
       31
        
             };

     

       32
       32
        
             pam = mkOption {

     

       33
       33
       -
               description = "Settings for <literal>pam_mysql</literal>";

     

       33
       33
       +
               description = lib.mdDoc "Settings for `pam_mysql`";

     

       34
       34
        
               type = types.submodule {

     

       35
       35
        
                 options = {

     

       36
       36
        
                   table = mkOption {

     

       37
       37
        
                     type = types.str;

     

       38
       38
        
                     example = "users";

     

       39
       39
       -
                     description = "The name of table that maps unique login names to the passwords.";

     

       39
       39
       +
                     description = lib.mdDoc "The name of table that maps unique login names to the passwords.";

     

       40
       40
        
                   };

     

       41
       41
        
                   updateTable = mkOption {

     

       42
       42
        
                     type = types.nullOr types.str;

     

       43
       43
        
                     default = null;

     

       44
       44
        
                     example = "users_updates";

     

       45
       45
       -
                     description = ''

     

       45
       45
       +
                     description = lib.mdDoc ''

     

       46
       46
        
                       The name of the table used for password alteration. If not defined, the value

     

       47
       47
       -
                       of the <literal>table</literal> option will be used instead.

     

       47
       47
       +
                       of the `table` option will be used instead.

     

       48
       48
        
                     '';

     

       49
       49
        
                   };

     

       50
       50
        
                   userColumn = mkOption {

     

       51
       51
        
                     type = types.str;

     

       52
       52
        
                     example = "username";

     

       53
       53
       -
                     description = "The name of the column that contains a unix login name.";

     

       53
       53
       +
                     description = lib.mdDoc "The name of the column that contains a unix login name.";

     

       54
       54
        
                   };

     

       55
       55
        
                   passwordColumn = mkOption {

     

       56
       56
        
                     type = types.str;

     

       57
       57
        
                     example = "password";

     

       58
       58
       -
                     description = "The name of the column that contains a (encrypted) password string.";

     

       58
       58
       +
                     description = lib.mdDoc "The name of the column that contains a (encrypted) password string.";

     

       59
       59
        
                   };

     

       60
       60
        
                   statusColumn = mkOption {

     

       61
       61
        
                     type = types.nullOr types.str;

     
···

       123
       123
        
                     type = types.nullOr (types.enum [ "md5" "sha256" "sha512" "blowfish" ]);

     

       124
       124
        
                     default = null;

     

       125
       125
        
                     example = "blowfish";

     

       126
       126
       -
                     description = "The default encryption method to use for <literal>passwordCrypt = 1</literal>.";

     

       126
       126
       +
                     description = lib.mdDoc "The default encryption method to use for `passwordCrypt = 1`.";

     

       127
       127
        
                   };

     

       128
       128
        
                   where = mkOption {

     

       129
       129
        
                     type = types.nullOr types.str;

     

       130
       130
        
                     default = null;

     

       131
       131
        
                     example = "host.name='web' AND user.active=1";

     

       132
       132
       -
                     description = "Additional criteria for the query.";

     

       132
       132
       +
                     description = lib.mdDoc "Additional criteria for the query.";

     

       133
       133
        
                   };

     

       134
       134
        
                   verbose = mkOption {

     

       135
       135
        
                     type = types.bool;

     

       136
       136
        
                     default = false;

     

       137
       137
       -
                     description = ''

     

       137
       137
       +
                     description = lib.mdDoc ''

     

       138
       138
        
                       If enabled, produces logs with detailed messages that describes what

     

       139
       139
       -
                       <literal>pam_mysql</literal> is doing. May be useful for debugging.

     

       139
       139
       +
                       `pam_mysql` is doing. May be useful for debugging.

     

       140
       140
        
                     '';

     

       141
       141
        
                   };

     

       142
       142
        
                   disconnectEveryOperation = mkOption {

     

       143
       143
        
                     type = types.bool;

     

       144
       144
        
                     default = false;

     

       145
       145
       -
                     description = ''

     

       146
       146
       -
                       By default, <literal>pam_mysql</literal> keeps the connection to the MySQL

     

       145
       145
       +
                     description = lib.mdDoc ''

     

       146
       146
       +
                       By default, `pam_mysql` keeps the connection to the MySQL

     

       147
       147
        
                       database until the session is closed. If this option is set to true it

     

       148
       148
        
                       disconnects every time the PAM operation has finished. This option may

     

       149
       149
        
                       be useful in case the session lasts quite long.

     
···

       153
       153
        
                     enable = mkOption {

     

       154
       154
        
                       type = types.bool;

     

       155
       155
        
                       default = false;

     

       156
       156
       -
                       description = "Enables logging of authentication attempts in the MySQL database.";

     

       156
       156
       +
                       description = lib.mdDoc "Enables logging of authentication attempts in the MySQL database.";

     

       157
       157
        
                     };

     

       158
       158
        
                     table = mkOption {

     

       159
       159
        
                       type = types.str;

     

       160
       160
        
                       example = "logs";

     

       161
       161
       -
                       description = "The name of the table to which logs are written.";

     

       161
       161
       +
                       description = lib.mdDoc "The name of the table to which logs are written.";

     

       162
       162
        
                     };

     

       163
       163
        
                     msgColumn = mkOption {

     

       164
       164
        
                       type = types.str;

     

       165
       165
        
                       example = "msg";

     

       166
       166
       -
                       description = ''

     

       166
       166
       +
                       description = lib.mdDoc ''

     

       167
       167
        
                         The name of the column in the log table to which the description

     

       168
       168
        
                         of the performed operation is stored.

     

       169
       169
        
                       '';

     
···

       171
       171
        
                     userColumn = mkOption {

     

       172
       172
        
                       type = types.str;

     

       173
       173
        
                       example = "user";

     

       174
       174
       -
                       description = ''

     

       174
       174
       +
                       description = lib.mdDoc ''

     

       175
       175
        
                         The name of the column in the log table to which the name of the

     

       176
       176
        
                         user being authenticated is stored.

     

       177
       177
        
                       '';

     
···

       179
       179
        
                     pidColumn = mkOption {

     

       180
       180
        
                       type = types.str;

     

       181
       181
        
                       example = "pid";

     

       182
       182
       -
                       description = ''

     

       182
       182
       +
                       description = lib.mdDoc ''

     

       183
       183
        
                         The name of the column in the log table to which the pid of the

     

       184
       184
       -
                         process utilising the <literal>pam_mysql's</literal> authentication

     

       184
       184
       +
                         process utilising the `pam_mysql's` authentication

     

       185
       185
        
                         service is stored.

     

       186
       186
        
                       '';

     

       187
       187
        
                     };

     

       188
       188
        
                     hostColumn = mkOption {

     

       189
       189
        
                       type = types.str;

     

       190
       190
        
                       example = "host";

     

       191
       191
       -
                       description = ''

     

       191
       191
       +
                       description = lib.mdDoc ''

     

       192
       192
        
                         The name of the column in the log table to which the name of the user

     

       193
       193
        
                         being authenticated is stored.

     

       194
       194
        
                       '';

     
···

       196
       196
        
                     rHostColumn = mkOption {

     

       197
       197
        
                       type = types.str;

     

       198
       198
        
                       example = "rhost";

     

       199
       199
       -
                       description = ''

     

       199
       199
       +
                       description = lib.mdDoc ''

     

       200
       200
        
                         The name of the column in the log table to which the name of the remote

     

       201
       201
        
                         host that initiates the session is stored. The value is supposed to be

     

       202
       202
       -
                         set by the PAM-aware application with <literal>pam_set_item(PAM_RHOST)</literal>.

     

       202
       202
       +
                         set by the PAM-aware application with `pam_set_item(PAM_RHOST)`.

     

       203
       203
        
                       '';

     

       204
       204
        
                     };

     

       205
       205
        
                     timeColumn = mkOption {

     

       206
       206
        
                       type = types.str;

     

       207
       207
        
                       example = "timestamp";

     

       208
       208
       -
                       description = ''

     

       208
       208
       +
                       description = lib.mdDoc ''

     

       209
       209
        
                         The name of the column in the log table to which the timestamp of the

     

       210
       210
        
                         log entry is stored.

     

       211
       211
        
                       '';

     
···

       215
       215
        
               };

     

       216
       216
        
             };

     

       217
       217
        
             nss = mkOption {

     

       218
       218
       -
               description = ''

     

       219
       219
       -
                 Settings for <literal>libnss-mysql</literal>.

     

       218
       218
       +
               description = lib.mdDoc ''

     

       219
       219
       +
                 Settings for `libnss-mysql`.

     

       220
       220
        
       

     

       221
       221
       -
                 All examples are from the <link xlink:href="https://github.com/saknopper/libnss-mysql/tree/master/sample/minimal">minimal example</link>

     

       222
       222
       -
                 of <literal>libnss-mysql</literal>, but they are modified with NixOS paths for bash.

     

       221
       221
       +
                 All examples are from the [minimal example](https://github.com/saknopper/libnss-mysql/tree/master/sample/minimal)

     

       222
       222
       +
                 of `libnss-mysql`, but they are modified with NixOS paths for bash.

     

       223
       223
        
               '';

     

       224
       224
        
               type = types.submodule {

     

       225
       225
        
                 options = {

     
···

       232
       232
        
                       WHERE username='%1$s' \

     

       233
       233
        
                       LIMIT 1

     

       234
       234
        
                     '';

     

       235
       235
       -
                     description = ''

     

       236
       236
       -
                       SQL query for the <link xlink:href="https://man7.org/linux/man-pages/man3/getpwnam.3.html">getpwnam</link>

     

       235
       235
       +
                     description = lib.mdDoc ''

     

       236
       236
       +
                       SQL query for the [getpwnam](https://man7.org/linux/man-pages/man3/getpwnam.3.html)

     

       237
       237
        
                       syscall.

     

       238
       238
        
                     '';

     

       239
       239
        
                   };

     
···

       246
       246
        
                       WHERE uid='%1$u' \

     

       247
       247
        
                       LIMIT 1

     

       248
       248
        
                     '';

     

       249
       249
       -
                     description = ''

     

       250
       250
       -
                       SQL query for the <link xlink:href="https://man7.org/linux/man-pages/man3/getpwuid.3.html">getpwuid</link>

     

       249
       249
       +
                     description = lib.mdDoc ''

     

       250
       250
       +
                       SQL query for the [getpwuid](https://man7.org/linux/man-pages/man3/getpwuid.3.html)

     

       251
       251
        
                       syscall.

     

       252
       252
        
                     '';

     

       253
       253
        
                   };

     
···

       260
       260
        
                       WHERE username='%1$s' \

     

       261
       261
        
                       LIMIT 1

     

       262
       262
        
                     '';

     

       263
       263
       -
                     description = ''

     

       264
       264
       -
                       SQL query for the <link xlink:href="https://man7.org/linux/man-pages/man3/getspnam.3.html">getspnam</link>

     

       263
       263
       +
                     description = lib.mdDoc ''

     

       264
       264
       +
                       SQL query for the [getspnam](https://man7.org/linux/man-pages/man3/getspnam.3.html)

     

       265
       265
        
                       syscall.

     

       266
       266
        
                     '';

     

       267
       267
        
                   };

     
···

       271
       271
        
                     example = literalExpression ''

     

       272
       272
        
                       SELECT username,'x',uid,'5000','MySQL User', CONCAT('/home/',username),'/run/sw/current-system/bin/bash' FROM users

     

       273
       273
        
                     '';

     

       274
       274
       -
                     description = ''

     

       275
       275
       -
                       SQL query for the <link xlink:href="https://man7.org/linux/man-pages/man3/getpwent.3.html">getpwent</link>

     

       274
       274
       +
                     description = lib.mdDoc ''

     

       275
       275
       +
                       SQL query for the [getpwent](https://man7.org/linux/man-pages/man3/getpwent.3.html)

     

       276
       276
        
                       syscall.

     

       277
       277
        
                     '';

     

       278
       278
        
                   };

     
···

       282
       282
        
                     example = literalExpression ''

     

       283
       283
        
                       SELECT username,password,'1','0','99999','0','0','-1','0' FROM users

     

       284
       284
        
                     '';

     

       285
       285
       -
                     description = ''

     

       286
       286
       -
                       SQL query for the <link xlink:href="https://man7.org/linux/man-pages/man3/getspent.3.html">getspent</link>

     

       285
       285
       +
                     description = lib.mdDoc ''

     

       286
       286
       +
                       SQL query for the [getspent](https://man7.org/linux/man-pages/man3/getspent.3.html)

     

       287
       287
        
                       syscall.

     

       288
       288
        
                     '';

     

       289
       289
        
                   };

     
···

       293
       293
        
                     example = literalExpression ''

     

       294
       294
        
                       SELECT name,password,gid FROM groups WHERE name='%1$s' LIMIT 1

     

       295
       295
        
                     '';

     

       296
       296
       -
                     description = ''

     

       297
       297
       -
                       SQL query for the <link xlink:href="https://man7.org/linux/man-pages/man3/getgrnam.3.html">getgrnam</link>

     

       296
       296
       +
                     description = lib.mdDoc ''

     

       297
       297
       +
                       SQL query for the [getgrnam](https://man7.org/linux/man-pages/man3/getgrnam.3.html)

     

       298
       298
        
                       syscall.

     

       299
       299
        
                     '';

     

       300
       300
        
                   };

     
···

       304
       304
        
                     example = literalExpression ''

     

       305
       305
        
                       SELECT name,password,gid FROM groups WHERE gid='%1$u' LIMIT 1

     

       306
       306
        
                     '';

     

       307
       307
       -
                     description = ''

     

       308
       308
       -
                       SQL query for the <link xlink:href="https://man7.org/linux/man-pages/man3/getgrgid.3.html">getgrgid</link>

     

       307
       307
       +
                     description = lib.mdDoc ''

     

       308
       308
       +
                       SQL query for the [getgrgid](https://man7.org/linux/man-pages/man3/getgrgid.3.html)

     

       309
       309
        
                       syscall.

     

       310
       310
        
                     '';

     

       311
       311
        
                   };

     
···

       315
       315
        
                     example = literalExpression ''

     

       316
       316
        
                       SELECT name,password,gid FROM groups

     

       317
       317
        
                     '';

     

       318
       318
       -
                     description = ''

     

       319
       319
       -
                       SQL query for the <link xlink:href="https://man7.org/linux/man-pages/man3/getgrent.3.html">getgrent</link>

     

       318
       318
       +
                     description = lib.mdDoc ''

     

       319
       319
       +
                       SQL query for the [getgrent](https://man7.org/linux/man-pages/man3/getgrent.3.html)

     

       320
       320
        
                       syscall.

     

       321
       321
        
                     '';

     

       322
       322
        
                   };

     
···

       326
       326
        
                     example = literalExpression ''

     

       327
       327
        
                       SELECT username FROM grouplist WHERE gid='%1$u'

     

       328
       328
        
                     '';

     

       329
       329
       -
                     description = ''

     

       330
       330
       -
                       SQL query for the <link xlink:href="https://man7.org/linux/man-pages/man3/memsbygid.3.html">memsbygid</link>

     

       329
       329
       +
                     description = lib.mdDoc ''

     

       330
       330
       +
                       SQL query for the [memsbygid](https://man7.org/linux/man-pages/man3/memsbygid.3.html)

     

       331
       331
        
                       syscall.

     

       332
       332
        
                     '';

     

       333
       333
        
                   };

     
···

       337
       337
        
                     example = literalExpression ''

     

       338
       338
        
                       SELECT gid FROM grouplist WHERE username='%1$s'

     

       339
       339
        
                     '';

     

       340
       340
       -
                     description = ''

     

       341
       341
       -
                       SQL query for the <link xlink:href="https://man7.org/linux/man-pages/man3/gidsbymem.3.html">gidsbymem</link>

     

       340
       340
       +
                     description = lib.mdDoc ''

     

       341
       341
       +
                       SQL query for the [gidsbymem](https://man7.org/linux/man-pages/man3/gidsbymem.3.html)

     

       342
       342
        
                       syscall.

     

       343
       343
        
                     '';

     

       344
       344
        
                   };

+4 -4

nixos/modules/config/pulseaudio.nix

···

       190
       190
        
       

     

       191
       191
        
             zeroconf = {

     

       192
       192
        
               discovery.enable =

     

       193
       193
       -
                 mkEnableOption "discovery of pulseaudio sinks in the local network";

     

       193
       193
       +
                 mkEnableOption (lib.mdDoc "discovery of pulseaudio sinks in the local network");

     

       194
       194
        
               publish.enable =

     

       195
       195
       -
                 mkEnableOption "publishing the pulseaudio sink in the local network";

     

       195
       195
       +
                 mkEnableOption (lib.mdDoc "publishing the pulseaudio sink in the local network");

     

       196
       196
        
             };

     

       197
       197
        
       

     

       198
       198
        
             # TODO: enable by default?

     

       199
       199
        
             tcp = {

     

       200
       200
       -
               enable = mkEnableOption "tcp streaming support";

     

       200
       200
       +
               enable = mkEnableOption (lib.mdDoc "tcp streaming support");

     

       201
       201
        
       

     

       202
       202
        
               anonymousClients = {

     

       203
       203
       -
                 allowAll = mkEnableOption "all anonymous clients to stream to the server";

     

       203
       203
       +
                 allowAll = mkEnableOption (lib.mdDoc "all anonymous clients to stream to the server");

     

       204
       204
        
                 allowedIpRanges = mkOption {

     

       205
       205
        
                   type = types.listOf types.str;

     

       206
       206
        
                   default = [];

+1 -1

nixos/modules/config/qt5.nix

···

       27
       27
        
         options = {

     

       28
       28
        
           qt5 = {

     

       29
       29
        
       

     

       30
       30
       -
             enable = mkEnableOption "Qt5 theming configuration";

     

       30
       30
       +
             enable = mkEnableOption (lib.mdDoc "Qt5 theming configuration");

     

       31
       31
        
       

     

       32
       32
        
             platformTheme = mkOption {

     

       33
       33
        
               type = types.enum [

+2 -2

nixos/modules/config/swap.nix

···

       73
       73
        
             label = mkOption {

     

       74
       74
        
               example = "swap";

     

       75
       75
        
               type = types.str;

     

       76
       76
       -
               description = ''

     

       77
       77
       -
                 Label of the device.  Can be used instead of <varname>device</varname>.

     

       76
       76
       +
               description = lib.mdDoc ''

     

       77
       77
       +
                 Label of the device.  Can be used instead of {var}`device`.

     

       78
       78
        
               '';

     

       79
       79
        
             };

     

       80
       80

+1 -1

nixos/modules/config/xdg/portal.nix

···

       33
       33
        
       

     

       34
       34
        
         options.xdg.portal = {

     

       35
       35
        
           enable =

     

       36
       36
       -
             mkEnableOption ''<link xlink:href="https://github.com/flatpak/xdg-desktop-portal">xdg desktop integration</link>'' // {

     

       36
       36
       +
             mkEnableOption (lib.mdDoc ''[xdg desktop integration](https://github.com/flatpak/xdg-desktop-portal)'') // {

     

       37
       37
        
               default = false;

     

       38
       38
        
             };

     

       39
       39

+4 -4

nixos/modules/config/xdg/portals/lxqt.nix

···

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         options.xdg.portal.lxqt = {

     

       15
       15
       -
           enable = mkEnableOption ''

     

       15
       15
       +
           enable = mkEnableOption (lib.mdDoc ''

     

       16
       16
        
             the desktop portal for the LXQt desktop environment.

     

       17
       17
        
       

     

       18
       18
       -
             This will add the <literal>lxqt.xdg-desktop-portal-lxqt</literal>

     

       18
       18
       +
             This will add the `lxqt.xdg-desktop-portal-lxqt`

     

       19
       19
        
             package (with the extra Qt styles) into the

     

       20
       20
       -
             <option>xdg.portal.extraPortals</option> option

     

       21
       21
       -
           '';

     

       20
       20
       +
             {option}`xdg.portal.extraPortals` option

     

       21
       21
       +
           '');

     

       22
       22
        
       

     

       23
       23
        
           styles = mkOption {

     

       24
       24
        
             type = types.listOf types.package;

+4 -4

nixos/modules/config/xdg/portals/wlr.nix

···

       14
       14
        
         };

     

       15
       15
        
       

     

       16
       16
        
         options.xdg.portal.wlr = {

     

       17
       17
       -
           enable = mkEnableOption ''

     

       17
       17
       +
           enable = mkEnableOption (lib.mdDoc ''

     

       18
       18
        
             desktop portal for wlroots-based desktops

     

       19
       19
        
       

     

       20
       20
       -
             This will add the <literal>xdg-desktop-portal-wlr</literal> package into

     

       21
       21
       -
             the <option>xdg.portal.extraPortals</option> option, and provide the

     

       20
       20
       +
             This will add the `xdg-desktop-portal-wlr` package into

     

       21
       21
       +
             the {option}`xdg.portal.extraPortals` option, and provide the

     

       22
       22
        
             configuration file

     

       23
       23
       -
           '';

     

       23
       23
       +
           '');

     

       24
       24
        
       

     

       25
       25
        
           settings = mkOption {

     

       26
       26
        
             description = lib.mdDoc ''

+2 -2

nixos/modules/hardware/brillo.nix

···

       7
       7
        
       {

     

       8
       8
        
         options = {

     

       9
       9
        
           hardware.brillo = {

     

       10
       10
       -
             enable = mkEnableOption ''

     

       10
       10
       +
             enable = mkEnableOption (lib.mdDoc ''

     

       11
       11
        
               Enable brillo in userspace.

     

       12
       12
        
               This will allow brightness control from users in the video group.

     

       13
       13
       -
             '';

     

       13
       13
       +
             '');

     

       14
       14
        
           };

     

       15
       15
        
         };

     

       16
       16

+1 -1

nixos/modules/hardware/ckb-next.nix

···

       13
       13
        
           ];

     

       14
       14
        
       

     

       15
       15
        
           options.hardware.ckb-next = {

     

       16
       16
       -
             enable = mkEnableOption "the Corsair keyboard/mouse driver";

     

       16
       16
       +
             enable = mkEnableOption (lib.mdDoc "the Corsair keyboard/mouse driver");

     

       17
       17
        
       

     

       18
       18
        
             gid = mkOption {

     

       19
       19
        
               type = types.nullOr types.int;

+4 -4

nixos/modules/hardware/corectrl.nix

···

       7
       7
        
       in

     

       8
       8
        
       {

     

       9
       9
        
         options.programs.corectrl = {

     

       10
       10
       -
           enable = mkEnableOption ''

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc ''

     

       11
       11
        
             A tool to overclock amd graphics cards and processors.

     

       12
       12
        
             Add your user to the corectrl group to run corectrl without needing to enter your password

     

       13
       13
       -
           '';

     

       13
       13
       +
           '');

     

       14
       14
        
       

     

       15
       15
        
           gpuOverclock = {

     

       16
       16
       -
             enable = mkEnableOption ''

     

       16
       16
       +
             enable = mkEnableOption (lib.mdDoc ''

     

       17
       17
        
               true

     

       18
       18
       -
             '';

     

       18
       18
       +
             '');

     

       19
       19
        
             ppfeaturemask = mkOption {

     

       20
       20
        
               type = types.str;

     

       21
       21
        
               default = "0xfffd7fff";

+1 -1

nixos/modules/hardware/cpu/amd-sev.nix

···

       6
       6
        
       in

     

       7
       7
        
         with lib; {

     

       8
       8
        
           options.hardware.cpu.amd.sev = {

     

       9
       9
       -
             enable = mkEnableOption "access to the AMD SEV device";

     

       9
       9
       +
             enable = mkEnableOption (lib.mdDoc "access to the AMD SEV device");

     

       10
       10
        
             user = mkOption {

     

       11
       11
        
               description = lib.mdDoc "Owner to assign to the SEV device.";

     

       12
       12
        
               type = types.str;

+1 -1

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

···

       20
       20
        
         };

     

       21
       21
        
       

     

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

     

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

     

       23
       23
       +
           enable = mkEnableOption (lib.mdDoc "access to the Intel SGX provisioning device");

     

       24
       24
        
           user = mkOption {

     

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

     

       26
       26
        
             type = types.str;

+1 -1

nixos/modules/hardware/flirc.nix

···

       3
       3
        
         cfg = config.hardware.flirc;

     

       4
       4
        
       in

     

       5
       5
        
       {

     

       6
       6
       -
         options.hardware.flirc.enable = lib.mkEnableOption "software to configure a Flirc USB device";

     

       6
       6
       +
         options.hardware.flirc.enable = lib.mkEnableOption (lib.mdDoc "software to configure a Flirc USB device");

     

       7
       7
        
       

     

       8
       8
        
         config = lib.mkIf cfg.enable {

     

       9
       9
        
           environment.systemPackages = [ pkgs.flirc ];

+1 -1

nixos/modules/hardware/gkraken.nix

···

       7
       7
        
       in

     

       8
       8
        
       {

     

       9
       9
        
         options.hardware.gkraken = {

     

       10
       10
       -
           enable = mkEnableOption "gkraken's udev rules for NZXT AIO liquid coolers";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "gkraken's udev rules for NZXT AIO liquid coolers");

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         config = mkIf cfg.enable {

+1 -1

nixos/modules/hardware/gpgsmartcards.nix

···

       28
       28
        
         cfg = config.hardware.gpgSmartcards;

     

       29
       29
        
       in {

     

       30
       30
        
         options.hardware.gpgSmartcards = {

     

       31
       31
       -
           enable = mkEnableOption "udev rules for gnupg smart cards";

     

       31
       31
       +
           enable = mkEnableOption (lib.mdDoc "udev rules for gnupg smart cards");

     

       32
       32
        
         };

     

       33
       33
        
       

     

       34
       34
        
         config = mkIf cfg.enable {

+2 -2

nixos/modules/hardware/i2c.nix

···

       8
       8
        
       

     

       9
       9
        
       {

     

       10
       10
        
         options.hardware.i2c = {

     

       11
       11
       -
           enable = mkEnableOption ''

     

       11
       11
       +
           enable = mkEnableOption (lib.mdDoc ''

     

       12
       12
        
             i2c devices support. By default access is granted to users in the "i2c"

     

       13
       13
        
             group (will be created if non-existent) and any user with a seat, meaning

     

       14
       14
        
             logged on the computer locally.

     

       15
       15
       -
           '';

     

       15
       15
       +
           '');

     

       16
       16
        
       

     

       17
       17
        
           group = mkOption {

     

       18
       18
        
             type = types.str;

+1 -1

nixos/modules/hardware/keyboard/teck.nix

···

       6
       6
        
       in

     

       7
       7
        
       {

     

       8
       8
        
         options.hardware.keyboard.teck = {

     

       9
       9
       -
           enable = mkEnableOption "non-root access to the firmware of TECK keyboards";

     

       9
       9
       +
           enable = mkEnableOption (lib.mdDoc "non-root access to the firmware of TECK keyboards");

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         config = mkIf cfg.enable {

+2 -2

nixos/modules/hardware/keyboard/uhk.nix

···

       6
       6
        
       in

     

       7
       7
        
       {

     

       8
       8
        
         options.hardware.keyboard.uhk = {

     

       9
       9
       -
           enable = mkEnableOption ''

     

       9
       9
       +
           enable = mkEnableOption (lib.mdDoc ''

     

       10
       10
        
           non-root access to the firmware of UHK keyboards.

     

       11
       11
        
             You need it when you want to flash a new firmware on the keyboard.

     

       12
       12
        
             Access to the keyboard is granted to users in the "input" group.

     

       13
       13
        
             You may want to install the uhk-agent package.

     

       14
       14
       -
           '';

     

       14
       14
       +
           '');

     

       15
       15
        
       

     

       16
       16
        
         };

     

       17
       17

+1 -1

nixos/modules/hardware/ksm.nix

···

       11
       11
        
         ];

     

       12
       12
        
       

     

       13
       13
        
         options.hardware.ksm = {

     

       14
       14
       -
           enable = mkEnableOption "Kernel Same-Page Merging";

     

       14
       14
       +
           enable = mkEnableOption (lib.mdDoc "Kernel Same-Page Merging");

     

       15
       15
        
           sleep = mkOption {

     

       16
       16
        
             type = types.nullOr types.int;

     

       17
       17
        
             default = null;

+1 -1

nixos/modules/hardware/ledger.nix

···

       6
       6
        
         cfg = config.hardware.ledger;

     

       7
       7
        
       

     

       8
       8
        
       in {

     

       9
       9
       -
         options.hardware.ledger.enable = mkEnableOption "udev rules for Ledger devices";

     

       9
       9
       +
         options.hardware.ledger.enable = mkEnableOption (lib.mdDoc "udev rules for Ledger devices");

     

       10
       10
        
       

     

       11
       11
        
         config = mkIf cfg.enable {

     

       12
       12
        
           services.udev.packages = [ pkgs.ledger-udev-rules ];

+2 -2

nixos/modules/hardware/logitech.nix

···

       19
       19
        
         options.hardware.logitech = {

     

       20
       20
        
       

     

       21
       21
        
           lcd = {

     

       22
       22
       -
             enable = mkEnableOption "Logitech LCD Devices";

     

       22
       22
       +
             enable = mkEnableOption (lib.mdDoc "Logitech LCD Devices");

     

       23
       23
        
       

     

       24
       24
        
             startWhenNeeded = mkOption {

     

       25
       25
        
               type = types.bool;

     
···

       41
       41
        
           };

     

       42
       42
        
       

     

       43
       43
        
           wireless = {

     

       44
       44
       -
             enable = mkEnableOption "Logitech Wireless Devices";

     

       44
       44
       +
             enable = mkEnableOption (lib.mdDoc "Logitech Wireless Devices");

     

       45
       45
        
       

     

       46
       46
        
             enableGraphical = mkOption {

     

       47
       47
        
               type = types.bool;

+2 -2

nixos/modules/hardware/openrazer.nix

···

       49
       49
        
       {

     

       50
       50
        
         options = {

     

       51
       51
        
           hardware.openrazer = {

     

       52
       52
       -
             enable = mkEnableOption ''

     

       52
       52
       +
             enable = mkEnableOption (lib.mdDoc ''

     

       53
       53
        
               OpenRazer drivers and userspace daemon.

     

       54
       54
       -
             '';

     

       54
       54
       +
             '');

     

       55
       55
        
       

     

       56
       56
        
             verboseLogging = mkOption {

     

       57
       57
        
               type = types.bool;

+1 -1

nixos/modules/hardware/raid/hpsa.nix

···

       48
       48
        
       

     

       49
       49
        
         options = {

     

       50
       50
        
           hardware.raid.HPSmartArray = {

     

       51
       51
       -
             enable = mkEnableOption "HP Smart Array kernel modules and CLI utility";

     

       51
       51
       +
             enable = mkEnableOption (lib.mdDoc "HP Smart Array kernel modules and CLI utility");

     

       52
       52
        
           };

     

       53
       53
        
         };

     

       54
       54

+1 -1

nixos/modules/hardware/saleae-logic.nix

···

       5
       5
        
       in

     

       6
       6
        
       {

     

       7
       7
        
         options.hardware.saleae-logic = {

     

       8
       8
       -
           enable = lib.mkEnableOption "udev rules for Saleae Logic devices";

     

       8
       8
       +
           enable = lib.mkEnableOption (lib.mdDoc "udev rules for Saleae Logic devices");

     

       9
       9
        
       

     

       10
       10
        
           package = lib.mkOption {

     

       11
       11
        
             type = lib.types.package;

+1 -1

nixos/modules/hardware/sata.nix

···

       36
       36
        
         meta.maintainers = with lib.maintainers; [ peterhoeg ];

     

       37
       37
        
       

     

       38
       38
        
         options.hardware.sata.timeout = {

     

       39
       39
       -
           enable = mkEnableOption "SATA drive timeouts";

     

       39
       39
       +
           enable = mkEnableOption (lib.mdDoc "SATA drive timeouts");

     

       40
       40
        
       

     

       41
       41
        
           deciSeconds = mkOption {

     

       42
       42
        
             example = 70;

+1 -1

nixos/modules/hardware/system-76.nix

···

       57
       57
        
       in {

     

       58
       58
        
         options = {

     

       59
       59
        
           hardware.system76 = {

     

       60
       60
       -
             enableAll = mkEnableOption "all recommended configuration for system76 systems";

     

       60
       60
       +
             enableAll = mkEnableOption (lib.mdDoc "all recommended configuration for system76 systems");

     

       61
       61
        
       

     

       62
       62
        
             firmware-daemon.enable = mkOption {

     

       63
       63
        
               default = cfg.enableAll;

+1 -1

nixos/modules/hardware/ubertooth.nix

···

       10
       10
        
         };

     

       11
       11
        
       in {

     

       12
       12
        
         options.hardware.ubertooth = {

     

       13
       13
       -
           enable = mkEnableOption "Enable the Ubertooth software and its udev rules.";

     

       13
       13
       +
           enable = mkEnableOption (lib.mdDoc "Enable the Ubertooth software and its udev rules.");

     

       14
       14
        
       

     

       15
       15
        
           group = mkOption {

     

       16
       16
        
             type = types.str;

+1 -1

nixos/modules/hardware/uinput.nix

···

       4
       4
        
         cfg = config.hardware.uinput;

     

       5
       5
        
       in {

     

       6
       6
        
         options.hardware.uinput = {

     

       7
       7
       -
           enable = lib.mkEnableOption "uinput support";

     

       7
       7
       +
           enable = lib.mkEnableOption (lib.mdDoc "uinput support");

     

       8
       8
        
         };

     

       9
       9
        
       

     

       10
       10
        
         config = lib.mkIf cfg.enable {

+1 -1

nixos/modules/hardware/video/capture/mwprocapture.nix

···

       12
       12
        
       

     

       13
       13
        
       {

     

       14
       14
        
       

     

       15
       15
       -
         options.hardware.mwProCapture.enable = mkEnableOption "Magewell Pro Capture family kernel module";

     

       15
       15
       +
         options.hardware.mwProCapture.enable = mkEnableOption (lib.mdDoc "Magewell Pro Capture family kernel module");

     

       16
       16
        
       

     

       17
       17
        
         config = mkIf cfg.enable {

     

       18
       18

+1 -1

nixos/modules/hardware/video/hidpi.nix

···

       2
       2
        
       with lib;

     

       3
       3
        
       

     

       4
       4
        
       {

     

       5
       5
       -
         options.hardware.video.hidpi.enable = mkEnableOption "Font/DPI configuration optimized for HiDPI displays";

     

       5
       5
       +
         options.hardware.video.hidpi.enable = mkEnableOption (lib.mdDoc "Font/DPI configuration optimized for HiDPI displays");

     

       6
       6
        
       

     

       7
       7
        
         config = mkIf config.hardware.video.hidpi.enable {

     

       8
       8
        
           console.font = lib.mkDefault "${pkgs.terminus_font}/share/consolefonts/ter-v32n.psf.gz";

+1 -1

nixos/modules/hardware/video/switcheroo-control.nix

···

       6
       6
        
         cfg = config.services.switcherooControl;

     

       7
       7
        
       in {

     

       8
       8
        
         options.services.switcherooControl = {

     

       9
       9
       -
           enable = mkEnableOption "switcheroo-control, a D-Bus service to check the availability of dual-GPU";

     

       9
       9
       +
           enable = mkEnableOption (lib.mdDoc "switcheroo-control, a D-Bus service to check the availability of dual-GPU");

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         config = mkIf cfg.enable {

+1 -1

nixos/modules/hardware/video/webcam/facetimehd.nix

···

       12
       12
        
       

     

       13
       13
        
       {

     

       14
       14
        
       

     

       15
       15
       -
         options.hardware.facetimehd.enable = mkEnableOption "facetimehd kernel module";

     

       15
       15
       +
         options.hardware.facetimehd.enable = mkEnableOption (lib.mdDoc "facetimehd kernel module");

     

       16
       16
        
       

     

       17
       17
        
         options.hardware.facetimehd.withCalibration = mkOption {

     

       18
       18
        
           default = false;

+1 -1

nixos/modules/hardware/wooting.nix

···

       3
       3
        
       with lib;

     

       4
       4
        
       {

     

       5
       5
        
         options.hardware.wooting.enable =

     

       6
       6
       -
           mkEnableOption "Enable support for Wooting keyboards";

     

       6
       6
       +
           mkEnableOption (lib.mdDoc "Enable support for Wooting keyboards");

     

       7
       7
        
       

     

       8
       8
        
         config = mkIf config.hardware.wooting.enable {

     

       9
       9
        
           environment.systemPackages = [ pkgs.wootility ];

+1 -1

nixos/modules/hardware/xone.nix

···

       6
       6
        
       in

     

       7
       7
        
       {

     

       8
       8
        
         options.hardware.xone = {

     

       9
       9
       -
           enable = mkEnableOption "the xone driver for Xbox One and Xbobx Series X|S accessories";

     

       9
       9
       +
           enable = mkEnableOption (lib.mdDoc "the xone driver for Xbox One and Xbobx Series X|S accessories");

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         config = mkIf cfg.enable {

+1 -1

nixos/modules/hardware/xpadneo.nix

···

       6
       6
        
       in

     

       7
       7
        
       {

     

       8
       8
        
         options.hardware.xpadneo = {

     

       9
       9
       -
           enable = mkEnableOption "the xpadneo driver for Xbox One wireless controllers";

     

       9
       9
       +
           enable = mkEnableOption (lib.mdDoc "the xpadneo driver for Xbox One wireless controllers");

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         config = mkIf cfg.enable {

+1 -1

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

···

       20
       20
        
               '';

     

       21
       21
        
             };

     

       22
       22
        
       

     

       23
       23
       -
             enableRimeData = mkEnableOption "default rime-data with fcitx5-rime";

     

       23
       23
       +
             enableRimeData = mkEnableOption (lib.mdDoc "default rime-data with fcitx5-rime");

     

       24
       24
        
           };

     

       25
       25
        
         };

     

       26
       26

+1 -1

nixos/modules/misc/man-db.nix

···

       7
       7
        
       {

     

       8
       8
        
         options = {

     

       9
       9
        
           documentation.man.man-db = {

     

       10
       10
       -
             enable = lib.mkEnableOption "man-db as the default man page viewer" // {

     

       10
       10
       +
             enable = lib.mkEnableOption (lib.mdDoc "man-db as the default man page viewer") // {

     

       11
       11
        
               default = config.documentation.man.enable;

     

       12
       12
        
               defaultText = lib.literalExpression "config.documentation.man.enable";

     

       13
       13
        
               example = false;

+1 -1

nixos/modules/misc/mandoc.nix

···

       10
       10
        
       

     

       11
       11
        
         options = {

     

       12
       12
        
           documentation.man.mandoc = {

     

       13
       13
       -
             enable = lib.mkEnableOption "mandoc as the default man page viewer";

     

       13
       13
       +
             enable = lib.mkEnableOption (lib.mdDoc "mandoc as the default man page viewer");

     

       14
       14
        
       

     

       15
       15
        
             manPath = lib.mkOption {

     

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

+1 -1

nixos/modules/misc/nixops-autoluks.nix

···

       5
       5
        
       

     

       6
       6
        
         inherit (config.nixops) enableDeprecatedAutoLuks;

     

       7
       7
        
       in {

     

       8
       8
       -
         options.nixops.enableDeprecatedAutoLuks = lib.mkEnableOption "Enable the deprecated NixOps AutoLuks module";

     

       8
       8
       +
         options.nixops.enableDeprecatedAutoLuks = lib.mkEnableOption (lib.mdDoc "Enable the deprecated NixOps AutoLuks module");

     

       9
       9
        
       

     

       10
       10
        
         config = {

     

       11
       11
        
           assertions = [

+1 -1

nixos/modules/misc/wordlist.nix

···

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
        
           environment.wordlist = {

     

       11
       11
       -
             enable = mkEnableOption "environment variables for lists of words";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "environment variables for lists of words");

     

       12
       12
        
       

     

       13
       13
        
             lists = mkOption {

     

       14
       14
        
               type = types.attrsOf (types.nonEmptyListOf types.path);

+1 -1

nixos/modules/programs/_1password-gui.nix

···

       16
       16
        
       

     

       17
       17
        
         options = {

     

       18
       18
        
           programs._1password-gui = {

     

       19
       19
       -
             enable = mkEnableOption "the 1Password GUI application";

     

       19
       19
       +
             enable = mkEnableOption (lib.mdDoc "the 1Password GUI application");

     

       20
       20
        
       

     

       21
       21
        
             polkitPolicyOwners = mkOption {

     

       22
       22
        
               type = types.listOf types.str;

+1 -1

nixos/modules/programs/_1password.nix

···

       16
       16
        
       

     

       17
       17
        
         options = {

     

       18
       18
        
           programs._1password = {

     

       19
       19
       -
             enable = mkEnableOption "the 1Password CLI tool";

     

       19
       19
       +
             enable = mkEnableOption (lib.mdDoc "the 1Password CLI tool");

     

       20
       20
        
       

     

       21
       21
        
             package = mkPackageOption pkgs "1Password CLI" {

     

       22
       22
        
               default = [ "_1password" ];

+1 -1

nixos/modules/programs/appgate-sdp.nix

···

       5
       5
        
       {

     

       6
       6
        
         options = {

     

       7
       7
        
           programs.appgate-sdp = {

     

       8
       8
       -
             enable = mkEnableOption "AppGate SDP VPN client";

     

       8
       8
       +
             enable = mkEnableOption (lib.mdDoc "AppGate SDP VPN client");

     

       9
       9
        
           };

     

       10
       10
        
         };

     

       11
       11

+1 -1

nixos/modules/programs/atop.nix

···

       14
       14
        
       

     

       15
       15
        
           programs.atop = rec {

     

       16
       16
        
       

     

       17
       17
       -
             enable = mkEnableOption "Atop";

     

       17
       17
       +
             enable = mkEnableOption (lib.mdDoc "Atop");

     

       18
       18
        
       

     

       19
       19
        
             package = mkOption {

     

       20
       20
        
               type = types.package;

+1 -1

nixos/modules/programs/bash-my-aws.nix

···

       13
       13
        
         {

     

       14
       14
        
           options = {

     

       15
       15
        
             programs.bash-my-aws = {

     

       16
       16
       -
               enable = mkEnableOption "bash-my-aws";

     

       16
       16
       +
               enable = mkEnableOption (lib.mdDoc "bash-my-aws");

     

       17
       17
        
             };

     

       18
       18
        
           };

     

       19
       19

+1 -1

nixos/modules/programs/bash/bash-completion.nix

···

       7
       7
        
       in

     

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
       -
           programs.bash.enableCompletion = mkEnableOption "Bash completion for all interactive bash shells" // {

     

       10
       10
       +
           programs.bash.enableCompletion = mkEnableOption (lib.mdDoc "Bash completion for all interactive bash shells") // {

     

       11
       11
        
             default = true;

     

       12
       12
        
           };

     

       13
       13
        
         };

+1 -1

nixos/modules/programs/bash/ls-colors.nix

···

       7
       7
        
       in

     

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
       -
           programs.bash.enableLsColors = mkEnableOption "extra colors in directory listings" // {

     

       10
       10
       +
           programs.bash.enableLsColors = mkEnableOption (lib.mdDoc "extra colors in directory listings") // {

     

       11
       11
        
             default = true;

     

       12
       12
        
           };

     

       13
       13
        
         };

+2 -2

nixos/modules/programs/bash/undistract-me.nix

···

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
        
           programs.bash.undistractMe = {

     

       11
       11
       -
             enable = mkEnableOption "notifications when long-running terminal commands complete";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "notifications when long-running terminal commands complete");

     

       12
       12
        
       

     

       13
       13
       -
             playSound = mkEnableOption "notification sounds when long-running terminal commands complete";

     

       13
       13
       +
             playSound = mkEnableOption (lib.mdDoc "notification sounds when long-running terminal commands complete");

     

       14
       14
        
       

     

       15
       15
        
             timeout = mkOption {

     

       16
       16
        
               default = 10;

+1 -1

nixos/modules/programs/bcc.nix

···

       1
       1
        
       { config, pkgs, lib, ... }:

     

       2
       2
        
       {

     

       3
       3
       -
         options.programs.bcc.enable = lib.mkEnableOption "bcc";

     

       3
       3
       +
         options.programs.bcc.enable = lib.mkEnableOption (lib.mdDoc "bcc");

     

       4
       4
        
       

     

       5
       5
        
         config = lib.mkIf config.programs.bcc.enable {

     

       6
       6
        
           environment.systemPackages = [ pkgs.bcc ];

+1 -1

nixos/modules/programs/browserpass.nix

···

       4
       4
        
       

     

       5
       5
        
       {

     

       6
       6
        
       

     

       7
       7
       -
         options.programs.browserpass.enable = mkEnableOption "Browserpass native messaging host";

     

       7
       7
       +
         options.programs.browserpass.enable = mkEnableOption (lib.mdDoc "Browserpass native messaging host");

     

       8
       8
        
       

     

       9
       9
        
         config = mkIf config.programs.browserpass.enable {

     

       10
       10
        
           environment.etc = let

+2 -2

nixos/modules/programs/calls.nix

···

       7
       7
        
       in {

     

       8
       8
        
         options = {

     

       9
       9
        
           programs.calls = {

     

       10
       10
       -
             enable = mkEnableOption ''

     

       10
       10
       +
             enable = mkEnableOption (lib.mdDoc ''

     

       11
       11
        
               Whether to enable GNOME calls: a phone dialer and call handler.

     

       12
       12
       -
             '';

     

       12
       12
       +
             '');

     

       13
       13
        
           };

     

       14
       14
        
         };

     

       15
       15

+1 -1

nixos/modules/programs/captive-browser.nix

···

       34
       34
        
       

     

       35
       35
        
         options = {

     

       36
       36
        
           programs.captive-browser = {

     

       37
       37
       -
             enable = mkEnableOption "captive browser";

     

       37
       37
       +
             enable = mkEnableOption (lib.mdDoc "captive browser");

     

       38
       38
        
       

     

       39
       39
        
             package = mkOption {

     

       40
       40
        
               type = types.package;

+1 -1

nixos/modules/programs/ccache.nix

···

       6
       6
        
       in {

     

       7
       7
        
         options.programs.ccache = {

     

       8
       8
        
           # host configuration

     

       9
       9
       -
           enable = mkEnableOption "CCache";

     

       9
       9
       +
           enable = mkEnableOption (lib.mdDoc "CCache");

     

       10
       10
        
           cacheDir = mkOption {

     

       11
       11
        
             type = types.path;

     

       12
       12
        
             description = lib.mdDoc "CCache directory";

+1 -1

nixos/modules/programs/cfs-zen-tweaks.nix

···

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         options = {

     

       20
       20
       -
           programs.cfs-zen-tweaks.enable = mkEnableOption "CFS Zen Tweaks";

     

       20
       20
       +
           programs.cfs-zen-tweaks.enable = mkEnableOption (lib.mdDoc "CFS Zen Tweaks");

     

       21
       21
        
         };

     

       22
       22
        
       

     

       23
       23
        
         config = mkIf cfg.enable {

+1 -1

nixos/modules/programs/chromium.nix

···

       19
       19
        
       

     

       20
       20
        
         options = {

     

       21
       21
        
           programs.chromium = {

     

       22
       22
       -
             enable = mkEnableOption "<command>chromium</command> policies";

     

       22
       22
       +
             enable = mkEnableOption (lib.mdDoc "{command}`chromium` policies");

     

       23
       23
        
       

     

       24
       24
        
             extensions = mkOption {

     

       25
       25
        
               type = types.listOf types.str;

+1 -1

nixos/modules/programs/cnping.nix

···

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
        
           programs.cnping = {

     

       11
       11
       -
             enable = mkEnableOption "Whether to install a setcap wrapper for cnping";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "Whether to install a setcap wrapper for cnping");

     

       12
       12
        
           };

     

       13
       13
        
         };

     

       14
       14

+1 -1

nixos/modules/programs/dconf.nix

···

       28
       28
        
       

     

       29
       29
        
         options = {

     

       30
       30
        
           programs.dconf = {

     

       31
       31
       -
             enable = mkEnableOption "dconf";

     

       31
       31
       +
             enable = mkEnableOption (lib.mdDoc "dconf");

     

       32
       32
        
       

     

       33
       33
        
             profiles = mkOption {

     

       34
       34
        
               type = types.attrsOf types.path;

+1 -1

nixos/modules/programs/droidcam.nix

···

       4
       4
        
       

     

       5
       5
        
       {

     

       6
       6
        
         options.programs.droidcam = {

     

       7
       7
       -
           enable = mkEnableOption "DroidCam client";

     

       7
       7
       +
           enable = mkEnableOption (lib.mdDoc "DroidCam client");

     

       8
       8
        
         };

     

       9
       9
        
       

     

       10
       10
        
         config = lib.mkIf config.programs.droidcam.enable {

+1 -1

nixos/modules/programs/evince.nix

···

       22
       22
        
           programs.evince = {

     

       23
       23
        
       

     

       24
       24
        
             enable = mkEnableOption

     

       25
       25
       -
               "Evince, the GNOME document viewer";

     

       25
       25
       +
               (lib.mdDoc "Evince, the GNOME document viewer");

     

       26
       26
        
       

     

       27
       27
        
             package = mkOption {

     

       28
       28
        
               type = types.package;

+2 -2

nixos/modules/programs/extra-container.nix

···

       5
       5
        
         cfg = config.programs.extra-container;

     

       6
       6
        
       in {

     

       7
       7
        
         options = {

     

       8
       8
       -
           programs.extra-container.enable = mkEnableOption ''

     

       8
       8
       +
           programs.extra-container.enable = mkEnableOption (lib.mdDoc ''

     

       9
       9
        
             extra-container, a tool for running declarative NixOS containers

     

       10
       10
        
             without host system rebuilds

     

       11
       11
       -
           '';

     

       11
       11
       +
           '');

     

       12
       12
        
         };

     

       13
       13
        
         config = mkIf cfg.enable {

     

       14
       14
        
           environment.systemPackages = [ pkgs.extra-container ];

+1 -1

nixos/modules/programs/file-roller.nix

···

       21
       21
        
       

     

       22
       22
        
           programs.file-roller = {

     

       23
       23
        
       

     

       24
       24
       -
             enable = mkEnableOption "File Roller, an archive manager for GNOME";

     

       24
       24
       +
             enable = mkEnableOption (lib.mdDoc "File Roller, an archive manager for GNOME");

     

       25
       25
        
       

     

       26
       26
        
             package = mkOption {

     

       27
       27
        
               type = types.package;

+1 -1

nixos/modules/programs/firejail.nix

···

       32
       32
        
       

     

       33
       33
        
       in {

     

       34
       34
        
         options.programs.firejail = {

     

       35
       35
       -
           enable = mkEnableOption "firejail";

     

       35
       35
       +
           enable = mkEnableOption (lib.mdDoc "firejail");

     

       36
       36
        
       

     

       37
       37
        
           wrappedBinaries = mkOption {

     

       38
       38
        
             type = types.attrsOf (types.either types.path (types.submodule {

+1 -1

nixos/modules/programs/flexoptix-app.nix

···

       7
       7
        
       in {

     

       8
       8
        
         options = {

     

       9
       9
        
           programs.flexoptix-app = {

     

       10
       10
       -
             enable = mkEnableOption "FLEXOPTIX app + udev rules";

     

       10
       10
       +
             enable = mkEnableOption (lib.mdDoc "FLEXOPTIX app + udev rules");

     

       11
       11
        
       

     

       12
       12
        
             package = mkOption {

     

       13
       13
        
               description = lib.mdDoc "FLEXOPTIX app package to use";

+2 -2

nixos/modules/programs/gamemode.nix

···

       10
       10
        
       {

     

       11
       11
        
         options = {

     

       12
       12
        
           programs.gamemode = {

     

       13
       13
       -
             enable = mkEnableOption "GameMode to optimise system performance on demand";

     

       13
       13
       +
             enable = mkEnableOption (lib.mdDoc "GameMode to optimise system performance on demand");

     

       14
       14
        
       

     

       15
       15
       -
             enableRenice = mkEnableOption "CAP_SYS_NICE on gamemoded to support lowering process niceness" // {

     

       15
       15
       +
             enableRenice = mkEnableOption (lib.mdDoc "CAP_SYS_NICE on gamemoded to support lowering process niceness") // {

     

       16
       16
        
               default = true;

     

       17
       17
        
             };

     

       18
       18

+1 -1

nixos/modules/programs/geary.nix

···

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         options = {

     

       14
       14
       -
           programs.geary.enable = mkEnableOption "Geary, a Mail client for GNOME 3";

     

       14
       14
       +
           programs.geary.enable = mkEnableOption (lib.mdDoc "Geary, a Mail client for GNOME 3");

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
        
         config = mkIf cfg.enable {

+2 -2

nixos/modules/programs/git.nix

···

       9
       9
        
       {

     

       10
       10
        
         options = {

     

       11
       11
        
           programs.git = {

     

       12
       12
       -
             enable = mkEnableOption "git";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "git");

     

       13
       13
        
       

     

       14
       14
        
             package = mkOption {

     

       15
       15
        
               type = types.package;

     
···

       33
       33
        
             };

     

       34
       34
        
       

     

       35
       35
        
             lfs = {

     

       36
       36
       -
               enable = mkEnableOption "git-lfs";

     

       36
       36
       +
               enable = mkEnableOption (lib.mdDoc "git-lfs");

     

       37
       37
        
       

     

       38
       38
        
               package = mkOption {

     

       39
       39
        
                 type = types.package;

+1 -1

nixos/modules/programs/gnome-terminal.nix

···

       24
       24
        
         ];

     

       25
       25
        
       

     

       26
       26
        
         options = {

     

       27
       27
       -
           programs.gnome-terminal.enable = mkEnableOption "GNOME Terminal";

     

       27
       27
       +
           programs.gnome-terminal.enable = mkEnableOption (lib.mdDoc "GNOME Terminal");

     

       28
       28
        
         };

     

       29
       29
        
       

     

       30
       30
        
         config = mkIf cfg.enable {

+1 -1

nixos/modules/programs/haguichi.nix

···

       4
       4
        
       

     

       5
       5
        
       {

     

       6
       6
        
         options.programs.haguichi = {

     

       7
       7
       -
           enable = mkEnableOption "Haguichi, a Linux GUI frontend to the proprietary LogMeIn Hamachi";

     

       7
       7
       +
           enable = mkEnableOption (lib.mdDoc "Haguichi, a Linux GUI frontend to the proprietary LogMeIn Hamachi");

     

       8
       8
        
         };

     

       9
       9
        
       

     

       10
       10
        
         config = mkIf config.programs.haguichi.enable {

+1 -1

nixos/modules/programs/hamster.nix

···

       6
       6
        
         meta.maintainers = pkgs.hamster.meta.maintainers;

     

       7
       7
        
       

     

       8
       8
        
         options.programs.hamster.enable =

     

       9
       9
       -
           mkEnableOption "hamster, a time tracking program";

     

       9
       9
       +
           mkEnableOption (lib.mdDoc "hamster, a time tracking program");

     

       10
       10
        
       

     

       11
       11
        
         config = lib.mkIf config.programs.hamster.enable {

     

       12
       12
        
           environment.systemPackages = [ pkgs.hamster ];

+1 -1

nixos/modules/programs/htop.nix

···

       26
       26
        
             '';

     

       27
       27
        
           };

     

       28
       28
        
       

     

       29
       29
       -
           enable = mkEnableOption "htop process monitor";

     

       29
       29
       +
           enable = mkEnableOption (lib.mdDoc "htop process monitor");

     

       30
       30
        
       

     

       31
       31
        
           settings = mkOption {

     

       32
       32
        
             type = with types; attrsOf (oneOf [ str int bool (listOf (oneOf [ str int bool ])) ]);

+1 -1

nixos/modules/programs/iftop.nix

···

       6
       6
        
         cfg = config.programs.iftop;

     

       7
       7
        
       in {

     

       8
       8
        
         options = {

     

       9
       9
       -
           programs.iftop.enable = mkEnableOption "iftop + setcap wrapper";

     

       9
       9
       +
           programs.iftop.enable = mkEnableOption (lib.mdDoc "iftop + setcap wrapper");

     

       10
       10
        
         };

     

       11
       11
        
         config = mkIf cfg.enable {

     

       12
       12
        
           environment.systemPackages = [ pkgs.iftop ];

+1 -1

nixos/modules/programs/iotop.nix

···

       6
       6
        
         cfg = config.programs.iotop;

     

       7
       7
        
       in {

     

       8
       8
        
         options = {

     

       9
       9
       -
           programs.iotop.enable = mkEnableOption "iotop + setcap wrapper";

     

       9
       9
       +
           programs.iotop.enable = mkEnableOption (lib.mdDoc "iotop + setcap wrapper");

     

       10
       10
        
         };

     

       11
       11
        
         config = mkIf cfg.enable {

     

       12
       12
        
           security.wrappers.iotop = {

+1 -1

nixos/modules/programs/k40-whisperer.nix

···

       10
       10
        
       in

     

       11
       11
        
       {

     

       12
       12
        
         options.programs.k40-whisperer = {

     

       13
       13
       -
           enable = mkEnableOption "K40-Whisperer";

     

       13
       13
       +
           enable = mkEnableOption (lib.mdDoc "K40-Whisperer");

     

       14
       14
        
       

     

       15
       15
        
           group = mkOption {

     

       16
       16
        
             type = types.str;

+1 -1

nixos/modules/programs/kbdlight.nix

···

       7
       7
        
       

     

       8
       8
        
       in

     

       9
       9
        
       {

     

       10
       10
       -
         options.programs.kbdlight.enable = mkEnableOption "kbdlight";

     

       10
       10
       +
         options.programs.kbdlight.enable = mkEnableOption (lib.mdDoc "kbdlight");

     

       11
       11
        
       

     

       12
       12
        
         config = mkIf cfg.enable {

     

       13
       13
        
           environment.systemPackages = [ pkgs.kbdlight ];

+1 -1

nixos/modules/programs/kclock.nix

···

       4
       4
        
         cfg = config.programs.kclock;

     

       5
       5
        
         kclockPkg = pkgs.libsForQt5.kclock;

     

       6
       6
        
       in {

     

       7
       7
       -
         options.programs.kclock = { enable = mkEnableOption "Enable KClock"; };

     

       7
       7
       +
         options.programs.kclock = { enable = mkEnableOption (lib.mdDoc "Enable KClock"); };

     

       8
       8
        
       

     

       9
       9
        
         config = mkIf cfg.enable {

     

       10
       10
        
           services.dbus.packages = [ kclockPkg ];

+4 -4

nixos/modules/programs/kdeconnect.nix

···

       2
       2
        
       with lib;

     

       3
       3
        
       {

     

       4
       4
        
         options.programs.kdeconnect = {

     

       5
       5
       -
           enable = mkEnableOption ''

     

       5
       5
       +
           enable = mkEnableOption (lib.mdDoc ''

     

       6
       6
        
             kdeconnect.

     

       7
       7
        
       

     

       8
       8
        
             Note that it will open the TCP and UDP port from

     

       9
       9
        
             1714 to 1764 as they are needed for it to function properly.

     

       10
       10
       -
             You can use the <option>package</option> to use

     

       11
       11
       -
             <literal>gnomeExtensions.gsconnect</literal> as an alternative

     

       10
       10
       +
             You can use the {option}`package` to use

     

       11
       11
       +
             `gnomeExtensions.gsconnect` as an alternative

     

       12
       12
        
             implementation if you use Gnome.

     

       13
       13
       -
           '';

     

       13
       13
       +
           '');

     

       14
       14
        
           package = mkOption {

     

       15
       15
        
             default = pkgs.plasma5Packages.kdeconnect-kde;

     

       16
       16
        
             defaultText = literalExpression "pkgs.plasma5Packages.kdeconnect-kde";

+1 -1

nixos/modules/programs/less.nix

···

       35
       35
        
       

     

       36
       36
        
             # note that environment.nix sets PAGER=less, and

     

       37
       37
        
             # therefore also enables this module

     

       38
       38
       -
             enable = mkEnableOption "less";

     

       38
       38
       +
             enable = mkEnableOption (lib.mdDoc "less");

     

       39
       39
        
       

     

       40
       40
        
             configFile = mkOption {

     

       41
       41
        
               type = types.nullOr types.path;

+1 -1

nixos/modules/programs/liboping.nix

···

       6
       6
        
         cfg = config.programs.liboping;

     

       7
       7
        
       in {

     

       8
       8
        
         options.programs.liboping = {

     

       9
       9
       -
           enable = mkEnableOption "liboping";

     

       9
       9
       +
           enable = mkEnableOption (lib.mdDoc "liboping");

     

       10
       10
        
         };

     

       11
       11
        
         config = mkIf cfg.enable {

     

       12
       12
        
           environment.systemPackages = with pkgs; [ liboping ];

+1 -1

nixos/modules/programs/mininet.nix

···

       28
       28
        
           '';

     

       29
       29
        
       in

     

       30
       30
        
       {

     

       31
       31
       -
         options.programs.mininet.enable = mkEnableOption "Mininet";

     

       31
       31
       +
         options.programs.mininet.enable = mkEnableOption (lib.mdDoc "Mininet");

     

       32
       32
        
       

     

       33
       33
        
         config = mkIf cfg.enable {

     

       34
       34

+1 -1

nixos/modules/programs/msmtp.nix

···

       10
       10
        
       

     

       11
       11
        
         options = {

     

       12
       12
        
           programs.msmtp = {

     

       13
       13
       -
             enable = mkEnableOption "msmtp - an SMTP client";

     

       13
       13
       +
             enable = mkEnableOption (lib.mdDoc "msmtp - an SMTP client");

     

       14
       14
        
       

     

       15
       15
        
             setSendmail = mkOption {

     

       16
       16
        
               type = types.bool;

+1 -1

nixos/modules/programs/nbd.nix

···

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
        
           programs.nbd = {

     

       11
       11
       -
             enable = mkEnableOption "Network Block Device (nbd) support";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "Network Block Device (nbd) support");

     

       12
       12
        
           };

     

       13
       13
        
         };

     

       14
       14

+1 -1

nixos/modules/programs/neovim.nix

···

       11
       11
        
       

     

       12
       12
        
       in {

     

       13
       13
        
         options.programs.neovim = {

     

       14
       14
       -
           enable = mkEnableOption "Neovim";

     

       14
       14
       +
           enable = mkEnableOption (lib.mdDoc "Neovim");

     

       15
       15
        
       

     

       16
       16
        
           defaultEditor = mkOption {

     

       17
       17
        
             type = types.bool;

+1 -1

nixos/modules/programs/nix-ld.nix

···

       2
       2
        
       {

     

       3
       3
        
         meta.maintainers = [ lib.maintainers.mic92 ];

     

       4
       4
        
         options = {

     

       5
       5
       -
           programs.nix-ld.enable = lib.mkEnableOption ''nix-ld, Documentation: <link xlink:href="https://github.com/Mic92/nix-ld"/>'';

     

       5
       5
       +
           programs.nix-ld.enable = lib.mkEnableOption (lib.mdDoc ''nix-ld, Documentation: <https://github.com/Mic92/nix-ld>'');

     

       6
       6
        
         };

     

       7
       7
        
         config = lib.mkIf config.programs.nix-ld.enable {

     

       8
       8
        
           systemd.tmpfiles.packages = [ pkgs.nix-ld ];

+1 -1

nixos/modules/programs/nm-applet.nix

···

       6
       6
        
         };

     

       7
       7
        
       

     

       8
       8
        
         options.programs.nm-applet = {

     

       9
       9
       -
           enable = lib.mkEnableOption "nm-applet";

     

       9
       9
       +
           enable = lib.mkEnableOption (lib.mdDoc "nm-applet");

     

       10
       10
        
       

     

       11
       11
        
           indicator = lib.mkOption {

     

       12
       12
        
             type = lib.types.bool;

+1 -1

nixos/modules/programs/nncp.nix

···

       11
       11
        
         options.programs.nncp = {

     

       12
       12
        
       

     

       13
       13
        
           enable =

     

       14
       14
       -
             mkEnableOption "NNCP (Node to Node copy) utilities and configuration";

     

       14
       14
       +
             mkEnableOption (lib.mdDoc "NNCP (Node to Node copy) utilities and configuration");

     

       15
       15
        
       

     

       16
       16
        
           group = mkOption {

     

       17
       17
        
             type = types.str;

+1 -1

nixos/modules/programs/noisetorch.nix

···

       6
       6
        
       in

     

       7
       7
        
       {

     

       8
       8
        
         options.programs.noisetorch = {

     

       9
       9
       -
           enable = mkEnableOption "noisetorch + setcap wrapper";

     

       9
       9
       +
           enable = mkEnableOption (lib.mdDoc "noisetorch + setcap wrapper");

     

       10
       10
        
       

     

       11
       11
        
           package = mkOption {

     

       12
       12
        
             type = types.package;

+1 -1

nixos/modules/programs/npm.nix

···

       11
       11
        
       

     

       12
       12
        
         options = {

     

       13
       13
        
           programs.npm = {

     

       14
       14
       -
             enable = mkEnableOption "<command>npm</command> global config";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "{command}`npm` global config");

     

       15
       15
        
       

     

       16
       16
        
             package = mkOption {

     

       17
       17
        
               type = types.package;

+1 -1

nixos/modules/programs/openvpn3.nix

···

       7
       7
        
       in

     

       8
       8
        
       {

     

       9
       9
        
         options.programs.openvpn3 = {

     

       10
       10
       -
           enable = mkEnableOption "the openvpn3 client";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "the openvpn3 client");

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         config = mkIf cfg.enable {

+1 -1

nixos/modules/programs/pantheon-tweaks.nix

···

       9
       9
        
       

     

       10
       10
        
         ###### interface

     

       11
       11
        
         options = {

     

       12
       12
       -
           programs.pantheon-tweaks.enable = mkEnableOption "Pantheon Tweaks, an unofficial system settings panel for Pantheon";

     

       12
       12
       +
           programs.pantheon-tweaks.enable = mkEnableOption (lib.mdDoc "Pantheon Tweaks, an unofficial system settings panel for Pantheon");

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         ###### implementation

+1 -1

nixos/modules/programs/partition-manager.nix

···

       7
       7
        
       

     

       8
       8
        
         ###### interface

     

       9
       9
        
         options = {

     

       10
       10
       -
           programs.partition-manager.enable = mkEnableOption "KDE Partition Manager";

     

       10
       10
       +
           programs.partition-manager.enable = mkEnableOption (lib.mdDoc "KDE Partition Manager");

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         ###### implementation

+3 -3

nixos/modules/programs/proxychains.nix

···

       22
       22
        
       

     

       23
       23
        
         proxyOptions = {

     

       24
       24
        
           options = {

     

       25
       25
       -
             enable = mkEnableOption "this proxy";

     

       25
       25
       +
             enable = mkEnableOption (lib.mdDoc "this proxy");

     

       26
       26
        
       

     

       27
       27
        
             type = mkOption {

     

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

     
···

       49
       49
        
       

     

       50
       50
        
           programs.proxychains = {

     

       51
       51
        
       

     

       52
       52
       -
             enable = mkEnableOption "installing proxychains configuration";

     

       52
       52
       +
             enable = mkEnableOption (lib.mdDoc "installing proxychains configuration");

     

       53
       53
        
       

     

       54
       54
        
             chain = {

     

       55
       55
        
               type = mkOption {

     
···

       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).";

     

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

     

       90
       90
        
       

     

       91
       91
        
             remoteDNSSubnet = mkOption {

     

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

+1 -1

nixos/modules/programs/seahorse.nix

···

       20
       20
        
       

     

       21
       21
        
           programs.seahorse = {

     

       22
       22
        
       

     

       23
       23
       -
             enable = mkEnableOption "Seahorse, a GNOME application for managing encryption keys and passwords in the GNOME Keyring";

     

       23
       23
       +
             enable = mkEnableOption (lib.mdDoc "Seahorse, a GNOME application for managing encryption keys and passwords in the GNOME Keyring");

     

       24
       24
        
       

     

       25
       25
        
           };

     

       26
       26

+1 -1

nixos/modules/programs/sedutil.nix

···

       6
       6
        
         cfg = config.programs.sedutil;

     

       7
       7
        
       

     

       8
       8
        
       in {

     

       9
       9
       -
         options.programs.sedutil.enable = mkEnableOption "sedutil";

     

       9
       9
       +
         options.programs.sedutil.enable = mkEnableOption (lib.mdDoc "sedutil");

     

       10
       10
        
       

     

       11
       11
        
         config = mkIf cfg.enable {

     

       12
       12
        
           boot.kernelParams = [

+1 -1

nixos/modules/programs/singularity.nix

···

       11
       11
        
         });

     

       12
       12
        
       in {

     

       13
       13
        
         options.programs.singularity = {

     

       14
       14
       -
           enable = mkEnableOption "Singularity";

     

       14
       14
       +
           enable = mkEnableOption (lib.mdDoc "Singularity");

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
        
         config = mkIf cfg.enable {

+1 -1

nixos/modules/programs/starship.nix

···

       11
       11
        
       

     

       12
       12
        
       in {

     

       13
       13
        
         options.programs.starship = {

     

       14
       14
       -
           enable = mkEnableOption "the Starship shell prompt";

     

       14
       14
       +
           enable = mkEnableOption (lib.mdDoc "the Starship shell prompt");

     

       15
       15
        
       

     

       16
       16
        
           settings = mkOption {

     

       17
       17
        
             inherit (settingsFormat) type;

+1 -1

nixos/modules/programs/steam.nix

···

       13
       13
        
         };

     

       14
       14
        
       in {

     

       15
       15
        
         options.programs.steam = {

     

       16
       16
       -
           enable = mkEnableOption "steam";

     

       16
       16
       +
           enable = mkEnableOption (lib.mdDoc "steam");

     

       17
       17
        
       

     

       18
       18
        
           remotePlay.openFirewall = mkOption {

     

       19
       19
        
             type = types.bool;

+1 -1

nixos/modules/programs/streamdeck-ui.nix

···

       6
       6
        
         cfg = config.programs.streamdeck-ui;

     

       7
       7
        
       in {

     

       8
       8
        
         options.programs.streamdeck-ui = {

     

       9
       9
       -
           enable = mkEnableOption "streamdeck-ui";

     

       9
       9
       +
           enable = mkEnableOption (lib.mdDoc "streamdeck-ui");

     

       10
       10
        
       

     

       11
       11
        
           autoStart = mkOption {

     

       12
       12
        
             default = true;

+3 -3

nixos/modules/programs/sway.nix

···

       35
       35
        
         };

     

       36
       36
        
       in {

     

       37
       37
        
         options.programs.sway = {

     

       38
       38
       -
           enable = mkEnableOption ''

     

       38
       38
       +
           enable = mkEnableOption (lib.mdDoc ''

     

       39
       39
        
             Sway, the i3-compatible tiling Wayland compositor. You can manually launch

     

       40
       40
        
             Sway by executing "exec sway" on a TTY. Copy /etc/sway/config to

     

       41
       41
        
             ~/.config/sway/config to modify the default configuration. See

     

       42
       42
       -
             <link xlink:href="https://github.com/swaywm/sway/wiki"/> and

     

       43
       43
       -
             "man 5 sway" for more information'';

     

       42
       42
       +
             <https://github.com/swaywm/sway/wiki> and

     

       43
       43
       +
             "man 5 sway" for more information'');

     

       44
       44
        
       

     

       45
       45
        
           wrapperFeatures = mkOption {

     

       46
       46
        
             type = wrapperOptions;

+1 -1

nixos/modules/programs/sysdig.nix

···

       5
       5
        
       let

     

       6
       6
        
         cfg = config.programs.sysdig;

     

       7
       7
        
       in {

     

       8
       8
       -
         options.programs.sysdig.enable = mkEnableOption "sysdig";

     

       8
       8
       +
         options.programs.sysdig.enable = mkEnableOption (lib.mdDoc "sysdig");

     

       9
       9
        
       

     

       10
       10
        
         config = mkIf cfg.enable {

     

       11
       11
        
           environment.systemPackages = [ pkgs.sysdig ];

+1 -1

nixos/modules/programs/system-config-printer.nix

···

       10
       10
        
       

     

       11
       11
        
           programs.system-config-printer = {

     

       12
       12
        
       

     

       13
       13
       -
             enable = mkEnableOption "system-config-printer, a Graphical user interface for CUPS administration";

     

       13
       13
       +
             enable = mkEnableOption (lib.mdDoc "system-config-printer, a Graphical user interface for CUPS administration");

     

       14
       14
        
       

     

       15
       15
        
           };

     

       16
       16

+1 -1

nixos/modules/programs/thefuck.nix

···

       16
       16
        
         {

     

       17
       17
        
           options = {

     

       18
       18
        
             programs.thefuck = {

     

       19
       19
       -
               enable = mkEnableOption "thefuck";

     

       19
       19
       +
               enable = mkEnableOption (lib.mdDoc "thefuck");

     

       20
       20
        
       

     

       21
       21
        
               alias = mkOption {

     

       22
       22
        
                 default = "fuck";

+1 -1

nixos/modules/programs/thunar.nix

···

       11
       11
        
       

     

       12
       12
        
         options = {

     

       13
       13
        
           programs.thunar = {

     

       14
       14
       -
             enable = mkEnableOption "Thunar, the Xfce file manager";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "Thunar, the Xfce file manager");

     

       15
       15
        
       

     

       16
       16
        
             plugins = mkOption {

     

       17
       17
        
               default = [];

+8 -8

nixos/modules/programs/tsm-client.nix

···

       65
       65
        
               directive in {file}`dsm.sys`.

     

       66
       66
        
             '';

     

       67
       67
        
           };

     

       68
       68
       -
           options.genPasswd = mkEnableOption ''

     

       68
       68
       +
           options.genPasswd = mkEnableOption (lib.mdDoc ''

     

       69
       69
        
             automatic client password generation.

     

       70
       70
        
             This option influences the

     

       71
       71
       -
             <literal>passwordaccess</literal>

     

       72
       72
       -
             directive in <filename>dsm.sys</filename>.

     

       71
       71
       +
             `passwordaccess`

     

       72
       72
       +
             directive in {file}`dsm.sys`.

     

       73
       73
        
             The password will be stored in the directory

     

       74
       74
       -
             given by the option <option>passwdDir</option>.

     

       75
       75
       -
             <emphasis>Caution</emphasis>:

     

       74
       74
       +
             given by the option {option}`passwdDir`.

     

       75
       75
       +
             *Caution*:

     

       76
       76
        
             If this option is enabled and the server forces

     

       77
       77
        
             to renew the password (e.g. on first connection),

     

       78
       78
        
             a random password will be generated and stored

     

       79
       79
       -
           '';

     

       79
       79
       +
           '');

     

       80
       80
        
           options.passwdDir = mkOption {

     

       81
       81
        
             type = path;

     

       82
       82
        
             example = "/home/alice/tsm-password";

     
···

       172
       172
        
         };

     

       173
       173
        
       

     

       174
       174
        
         options.programs.tsmClient = {

     

       175
       175
       -
           enable = mkEnableOption ''

     

       175
       175
       +
           enable = mkEnableOption (lib.mdDoc ''

     

       176
       176
        
             IBM Spectrum Protect (Tivoli Storage Manager, TSM)

     

       177
       177
        
             client command line applications with a

     

       178
       178
        
             client system-options file "dsm.sys"

     

       179
       179
       -
           '';

     

       179
       179
       +
           '');

     

       180
       180
        
           servers = mkOption {

     

       181
       181
        
             type = attrsOf (submodule [ serverOptions ]);

     

       182
       182
        
             default = {};

+1 -1

nixos/modules/programs/udevil.nix

···

       6
       6
        
         cfg = config.programs.udevil;

     

       7
       7
        
       

     

       8
       8
        
       in {

     

       9
       9
       -
         options.programs.udevil.enable = mkEnableOption "udevil";

     

       9
       9
       +
         options.programs.udevil.enable = mkEnableOption (lib.mdDoc "udevil");

     

       10
       10
        
       

     

       11
       11
        
         config = mkIf cfg.enable {

     

       12
       12
        
           security.wrappers.udevil =

+1 -1

nixos/modules/programs/usbtop.nix

···

       6
       6
        
         cfg = config.programs.usbtop;

     

       7
       7
        
       in {

     

       8
       8
        
         options = {

     

       9
       9
       -
           programs.usbtop.enable = mkEnableOption "usbtop and required kernel module";

     

       9
       9
       +
           programs.usbtop.enable = mkEnableOption (lib.mdDoc "usbtop and required kernel module");

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         config = mkIf cfg.enable {

+1 -1

nixos/modules/programs/waybar.nix

···

       4
       4
        
       

     

       5
       5
        
       {

     

       6
       6
        
         options.programs.waybar = {

     

       7
       7
       -
           enable = mkEnableOption "waybar";

     

       7
       7
       +
           enable = mkEnableOption (lib.mdDoc "waybar");

     

       8
       8
        
         };

     

       9
       9
        
       

     

       10
       10
        
         config = mkIf config.programs.waybar.enable {

+1 -1

nixos/modules/programs/weylus.nix

···

       7
       7
        
       in

     

       8
       8
        
       {

     

       9
       9
        
         options.programs.weylus = with types; {

     

       10
       10
       -
           enable = mkEnableOption "weylus";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "weylus");

     

       11
       11
        
       

     

       12
       12
        
           openFirewall = mkOption {

     

       13
       13
        
             type = bool;

+2 -2

nixos/modules/programs/wshowkeys.nix

···

       9
       9
        
       

     

       10
       10
        
         options = {

     

       11
       11
        
           programs.wshowkeys = {

     

       12
       12
       -
             enable = mkEnableOption ''

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc ''

     

       13
       13
        
               wshowkeys (displays keypresses on screen on supported Wayland

     

       14
       14
        
               compositors). It requires root permissions to read input events, but

     

       15
       15
       -
               these permissions are dropped after startup'';

     

       15
       15
       +
               these permissions are dropped after startup'');

     

       16
       16
        
           };

     

       17
       17
        
         };

     

       18
       18

+1 -1

nixos/modules/programs/xfconf.nix

···

       11
       11
        
       

     

       12
       12
        
         options = {

     

       13
       13
        
           programs.xfconf = {

     

       14
       14
       -
             enable = mkEnableOption "Xfconf, the Xfce configuration storage system";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "Xfconf, the Xfce configuration storage system");

     

       15
       15
        
           };

     

       16
       16
        
         };

     

       17
       17

+1 -1

nixos/modules/programs/xss-lock.nix

···

       7
       7
        
       in

     

       8
       8
        
       {

     

       9
       9
        
         options.programs.xss-lock = {

     

       10
       10
       -
           enable = mkEnableOption "xss-lock";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "xss-lock");

     

       11
       11
        
       

     

       12
       12
        
           lockerCommand = mkOption {

     

       13
       13
        
             default = "${pkgs.i3lock}/bin/i3lock";

+1 -1

nixos/modules/programs/xwayland.nix

···

       10
       10
        
       {

     

       11
       11
        
         options.programs.xwayland = {

     

       12
       12
        
       

     

       13
       13
       -
           enable = mkEnableOption "Xwayland (an X server for interfacing X11 apps with the Wayland protocol)";

     

       13
       13
       +
           enable = mkEnableOption (lib.mdDoc "Xwayland (an X server for interfacing X11 apps with the Wayland protocol)");

     

       14
       14
        
       

     

       15
       15
        
           defaultFontPath = mkOption {

     

       16
       16
        
             type = types.str;

+1 -1

nixos/modules/programs/yabar.nix

···

       41
       41
        
       in

     

       42
       42
        
         {

     

       43
       43
        
           options.programs.yabar = {

     

       44
       44
       -
             enable = mkEnableOption "yabar";

     

       44
       44
       +
             enable = mkEnableOption (lib.mdDoc "yabar");

     

       45
       45
        
       

     

       46
       46
        
             package = mkOption {

     

       47
       47
        
               default = pkgs.yabar-unstable;

+1 -1

nixos/modules/programs/zmap.nix

···

       6
       6
        
         cfg = config.programs.zmap;

     

       7
       7
        
       in {

     

       8
       8
        
         options.programs.zmap = {

     

       9
       9
       -
           enable = mkEnableOption "ZMap";

     

       9
       9
       +
           enable = mkEnableOption (lib.mdDoc "ZMap");

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         config = mkIf cfg.enable {

+1 -1

nixos/modules/programs/zsh/zsh-autoenv.nix

···

       7
       7
        
       in {

     

       8
       8
        
         options = {

     

       9
       9
        
           programs.zsh.zsh-autoenv = {

     

       10
       10
       -
             enable = mkEnableOption "zsh-autoenv";

     

       10
       10
       +
             enable = mkEnableOption (lib.mdDoc "zsh-autoenv");

     

       11
       11
        
             package = mkOption {

     

       12
       12
        
               default = pkgs.zsh-autoenv;

     

       13
       13
        
               defaultText = literalExpression "pkgs.zsh-autoenv";

+1 -1

nixos/modules/programs/zsh/zsh-autosuggestions.nix

···

       12
       12
        
       

     

       13
       13
        
         options.programs.zsh.autosuggestions = {

     

       14
       14
        
       

     

       15
       15
       -
           enable = mkEnableOption "zsh-autosuggestions";

     

       15
       15
       +
           enable = mkEnableOption (lib.mdDoc "zsh-autosuggestions");

     

       16
       16
        
       

     

       17
       17
        
           highlightStyle = mkOption {

     

       18
       18
        
             type = types.str;

+1 -1

nixos/modules/programs/zsh/zsh-syntax-highlighting.nix

···

       15
       15
        
       

     

       16
       16
        
         options = {

     

       17
       17
        
           programs.zsh.syntaxHighlighting = {

     

       18
       18
       -
             enable = mkEnableOption "zsh-syntax-highlighting";

     

       18
       18
       +
             enable = mkEnableOption (lib.mdDoc "zsh-syntax-highlighting");

     

       19
       19
        
       

     

       20
       20
        
             highlighters = mkOption {

     

       21
       21
        
               default = [ "main" ];

+1 -1

nixos/modules/security/acme/default.nix

···

       457
       457
        
               '';

     

       458
       458
        
             };

     

       459
       459
        
       

     

       460
       460
       -
             enableDebugLogs = mkEnableOption "debug logging for this certificate" // {

     

       460
       460
       +
             enableDebugLogs = mkEnableOption (lib.mdDoc "debug logging for this certificate") // {

     

       461
       461
        
               inherit (defaultAndText "enableDebugLogs" true) default defaultText;

     

       462
       462
        
             };

     

       463
       463

+12 -12

nixos/modules/security/apparmor.nix

···

       7
       7
        
         inherit (lib) types;

     

       8
       8
        
         inherit (config.environment) etc;

     

       9
       9
        
         cfg = config.security.apparmor;

     

       10
       10
       -
         mkDisableOption = name: mkEnableOption name // {

     

       10
       10
       +
         mkDisableOption = name: mkEnableOption (lib.mdDoc name) // {

     

       11
       11
        
           default = true;

     

       12
       12
        
           example = false;

     

       13
       13
        
         };

     
···

       24
       24
        
       

     

       25
       25
        
         options = {

     

       26
       26
        
           security.apparmor = {

     

       27
       27
       -
             enable = mkEnableOption ''

     

       27
       27
       +
             enable = mkEnableOption (lib.mdDoc ''

     

       28
       28
        
               the AppArmor Mandatory Access Control system.

     

       29
       29
        
       

     

       30
       30
        
               If you're enabling this module on a running system,

     
···

       38
       38
        
               introducing for the first time an AppArmor profile for the executable

     

       39
       39
        
               of a running process.

     

       40
       40
        
       

     

       41
       41
       -
               Enable <xref linkend="opt-security.apparmor.killUnconfinedConfinables"/>

     

       41
       41
       +
               Enable [](#opt-security.apparmor.killUnconfinedConfinables)

     

       42
       42
        
               if you want this service to do such killing

     

       43
       43
       -
               by sending a <literal>SIGTERM</literal> to those running processes'';

     

       43
       43
       +
               by sending a `SIGTERM` to those running processes'');

     

       44
       44
        
             policies = mkOption {

     

       45
       45
        
               description = lib.mdDoc ''

     

       46
       46
        
                 AppArmor policies.

     
···

       72
       72
        
               default = [];

     

       73
       73
        
               description = lib.mdDoc "List of packages to be added to AppArmor's include path";

     

       74
       74
        
             };

     

       75
       75
       -
             enableCache = mkEnableOption ''

     

       75
       75
       +
             enableCache = mkEnableOption (lib.mdDoc ''

     

       76
       76
        
               caching of AppArmor policies

     

       77
       77
       -
               in <literal>/var/cache/apparmor/</literal>.

     

       77
       77
       +
               in `/var/cache/apparmor/`.

     

       78
       78
        
       

     

       79
       79
        
               Beware that AppArmor policies almost always contain Nix store paths,

     

       80
       80
        
               and thus produce at each change of these paths

     

       81
       81
       -
               a new cached version accumulating in the cache'';

     

       82
       82
       -
             killUnconfinedConfinables = mkEnableOption ''

     

       81
       81
       +
               a new cached version accumulating in the cache'');

     

       82
       82
       +
             killUnconfinedConfinables = mkEnableOption (lib.mdDoc ''

     

       83
       83
        
               killing of processes which have an AppArmor profile enabled

     

       84
       84
       -
               (in <xref linkend="opt-security.apparmor.policies"/>)

     

       84
       84
       +
               (in [](#opt-security.apparmor.policies))

     

       85
       85
        
               but are not confined (because AppArmor can only confine new processes).

     

       86
       86
        
       

     

       87
       87
       -
               This is only sending a gracious <literal>SIGTERM</literal> signal to the processes,

     

       88
       88
       -
               not a <literal>SIGKILL</literal>.

     

       87
       87
       +
               This is only sending a gracious `SIGTERM` signal to the processes,

     

       88
       88
       +
               not a `SIGKILL`.

     

       89
       89
        
       

     

       90
       90
        
               Beware that due to a current limitation of AppArmor,

     

       91
       91
       -
               only profiles with exact paths (and no name) can enable such kills'';

     

       91
       91
       +
               only profiles with exact paths (and no name) can enable such kills'');

     

       92
       92
        
           };

     

       93
       93
        
         };

     

       94
       94

+1 -1

nixos/modules/security/auditd.nix

···

       3
       3
        
       with lib;

     

       4
       4
        
       

     

       5
       5
        
       {

     

       6
       6
       -
         options.security.auditd.enable = mkEnableOption "the Linux Audit daemon";

     

       6
       6
       +
         options.security.auditd.enable = mkEnableOption (lib.mdDoc "the Linux Audit daemon");

     

       7
       7
        
       

     

       8
       8
        
         config = mkIf config.security.auditd.enable {

     

       9
       9
        
           boot.kernelParams = [ "audit=1" ];

+9 -9

nixos/modules/security/pam.nix

···

       146
       146
        
               default = config.users.mysql.enable;

     

       147
       147
        
               defaultText = literalExpression "config.users.mysql.enable";

     

       148
       148
        
               type = types.bool;

     

       149
       149
       -
               description = ''

     

       150
       150
       -
                 If set, the <literal>pam_mysql</literal> module will be used to

     

       149
       149
       +
               description = lib.mdDoc ''

     

       150
       150
       +
                 If set, the `pam_mysql` module will be used to

     

       151
       151
        
                 authenticate users against a MySQL/MariaDB database.

     

       152
       152
        
               '';

     

       153
       153
        
             };

     
···

       773
       773
        
                 }

     

       774
       774
        
              ];

     

       775
       775
        
       

     

       776
       776
       -
            description = ''

     

       776
       776
       +
            description = lib.mdDoc ''

     

       777
       777
        
              Define resource limits that should apply to users or groups.

     

       778
       778
        
              Each item in the list should be an attribute set with a

     

       779
       779
       -
              <varname>domain</varname>, <varname>type</varname>,

     

       780
       780
       -
              <varname>item</varname>, and <varname>value</varname>

     

       779
       779
       +
              {var}`domain`, {var}`type`,

     

       780
       780
       +
              {var}`item`, and {var}`value`

     

       781
       781
        
              attribute.  The syntax and semantics of these attributes

     

       782
       782
       -
              must be that described in <citerefentry><refentrytitle>limits.conf</refentrytitle><manvolnum>5</manvolnum></citerefentry>.

     

       782
       782
       +
              must be that described in {manpage}`limits.conf(5)`.

     

       783
       783
        
       

     

       784
       784
        
              Note that these limits do not apply to systemd services,

     

       785
       785
       -
              whose limits can be changed via <option>systemd.extraConfig</option>

     

       785
       785
       +
              whose limits can be changed via {option}`systemd.extraConfig`

     

       786
       786
        
              instead.

     

       787
       787
        
            '';

     

       788
       788
        
           };

     
···

       822
       822
        
               '';

     

       823
       823
        
           };

     

       824
       824
        
       

     

       825
       825
       -
           security.pam.enableOTPW = mkEnableOption "the OTPW (one-time password) PAM module";

     

       825
       825
       +
           security.pam.enableOTPW = mkEnableOption (lib.mdDoc "the OTPW (one-time password) PAM module");

     

       826
       826
        
       

     

       827
       827
        
           security.pam.krb5 = {

     

       828
       828
        
             enable = mkOption {

     
···

       1145
       1145
        
             };

     

       1146
       1146
        
           };

     

       1147
       1147
        
       

     

       1148
       1148
       -
           security.pam.enableEcryptfs = mkEnableOption "eCryptfs PAM module (mounting ecryptfs home directory on login)";

     

       1148
       1148
       +
           security.pam.enableEcryptfs = mkEnableOption (lib.mdDoc "eCryptfs PAM module (mounting ecryptfs home directory on login)");

     

       1149
       1149
        
       

     

       1150
       1150
        
           users.motd = mkOption {

     

       1151
       1151
        
             default = null;

+1 -1

nixos/modules/security/polkit.nix

···

       12
       12
        
       

     

       13
       13
        
         options = {

     

       14
       14
        
       

     

       15
       15
       -
           security.polkit.enable = mkEnableOption "polkit";

     

       15
       15
       +
           security.polkit.enable = mkEnableOption (lib.mdDoc "polkit");

     

       16
       16
        
       

     

       17
       17
        
           security.polkit.extraConfig = mkOption {

     

       18
       18
        
             type = types.lines;

+6 -6

nixos/modules/security/tpm2.nix

···

       17
       17
        
       

     

       18
       18
        
       in {

     

       19
       19
        
         options.security.tpm2 = {

     

       20
       20
       -
           enable = lib.mkEnableOption "Trusted Platform Module 2 support";

     

       20
       20
       +
           enable = lib.mkEnableOption (lib.mdDoc "Trusted Platform Module 2 support");

     

       21
       21
        
       

     

       22
       22
        
           tssUser = lib.mkOption {

     

       23
       23
        
             description = lib.mdDoc ''

     
···

       48
       48
        
           };

     

       49
       49
        
       

     

       50
       50
        
           abrmd = {

     

       51
       51
       -
             enable = lib.mkEnableOption ''

     

       51
       51
       +
             enable = lib.mkEnableOption (lib.mdDoc ''

     

       52
       52
        
               Trusted Platform 2 userspace resource manager daemon

     

       53
       53
       -
             '';

     

       53
       53
       +
             '');

     

       54
       54
        
       

     

       55
       55
        
             package = lib.mkOption {

     

       56
       56
        
               description = lib.mdDoc "tpm2-abrmd package to use";

     
···

       61
       61
        
           };

     

       62
       62
        
       

     

       63
       63
        
           pkcs11 = {

     

       64
       64
       -
             enable = lib.mkEnableOption ''

     

       64
       64
       +
             enable = lib.mkEnableOption (lib.mdDoc ''

     

       65
       65
        
               TPM2 PKCS#11 tool and shared library in system path

     

       66
       66
       -
               (<literal>/run/current-system/sw/lib/libtpm2_pkcs11.so</literal>)

     

       67
       67
       -
             '';

     

       66
       66
       +
               (`/run/current-system/sw/lib/libtpm2_pkcs11.so`)

     

       67
       67
       +
             '');

     

       68
       68
        
       

     

       69
       69
        
             package = lib.mkOption {

     

       70
       70
        
               description = lib.mdDoc "tpm2-pkcs11 package to use";

+1 -1

nixos/modules/security/wrappers/default.nix

···

       189
       189
        
             default = "50%";

     

       190
       190
        
             example = "10G";

     

       191
       191
        
             type = lib.types.str;

     

       192
       192
       -
             description = ''

     

       192
       192
       +
             description = lib.mdDoc ''

     

       193
       193
        
               Size limit for the /run/wrappers tmpfs. Look at mount(8), tmpfs size option,

     

       194
       194
        
               for the accepted syntax. WARNING: don't set to less than 64MB.

     

       195
       195
        
             '';

+1 -1

nixos/modules/services/admin/meshcentral.nix

···

       5
       5
        
         configFile = configFormat.generate "meshcentral-config.json" cfg.settings;

     

       6
       6
        
       in with lib; {

     

       7
       7
        
         options.services.meshcentral = with types; {

     

       8
       8
       -
           enable = mkEnableOption "MeshCentral computer management server";

     

       8
       8
       +
           enable = mkEnableOption (lib.mdDoc "MeshCentral computer management server");

     

       9
       9
        
           package = mkOption {

     

       10
       10
        
             description = lib.mdDoc "MeshCentral package to use. Replacing this may be necessary to add dependencies for extra functionality.";

     

       11
       11
        
             type = types.package;

+1 -1

nixos/modules/services/admin/oxidized.nix

···

       7
       7
        
       in

     

       8
       8
        
       {

     

       9
       9
        
         options.services.oxidized = {

     

       10
       10
       -
           enable = mkEnableOption "the oxidized configuration backup service";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "the oxidized configuration backup service");

     

       11
       11
        
       

     

       12
       12
        
           user = mkOption {

     

       13
       13
        
             type = types.str;

+2 -2

nixos/modules/services/admin/pgadmin.nix

···

       28
       28
        
       in

     

       29
       29
        
       {

     

       30
       30
        
         options.services.pgadmin = {

     

       31
       31
       -
           enable = mkEnableOption "PostgreSQL Admin 4";

     

       31
       31
       +
           enable = mkEnableOption (lib.mdDoc "PostgreSQL Admin 4");

     

       32
       32
        
       

     

       33
       33
        
           port = mkOption {

     

       34
       34
        
             description = lib.mdDoc "Port for pgadmin4 to run on";

     
···

       49
       49
        
             type = types.path;

     

       50
       50
        
           };

     

       51
       51
        
       

     

       52
       52
       -
           openFirewall = mkEnableOption "firewall passthrough for pgadmin4";

     

       52
       52
       +
           openFirewall = mkEnableOption (lib.mdDoc "firewall passthrough for pgadmin4");

     

       53
       53
        
       

     

       54
       54
        
           settings = mkOption {

     

       55
       55
        
             description = lib.mdDoc ''

+1 -1

nixos/modules/services/admin/salt/master.nix

···

       20
       20
        
       {

     

       21
       21
        
         options = {

     

       22
       22
        
           services.salt.master = {

     

       23
       23
       -
             enable = mkEnableOption "Salt master service";

     

       23
       23
       +
             enable = mkEnableOption (lib.mdDoc "Salt master service");

     

       24
       24
        
             configuration = mkOption {

     

       25
       25
        
               type = types.attrs;

     

       26
       26
        
               default = {};

+1 -1

nixos/modules/services/admin/salt/minion.nix

···

       21
       21
        
       {

     

       22
       22
        
         options = {

     

       23
       23
        
           services.salt.minion = {

     

       24
       24
       -
             enable = mkEnableOption "Salt minion service";

     

       24
       24
       +
             enable = mkEnableOption (lib.mdDoc "Salt minion service");

     

       25
       25
        
             configuration = mkOption {

     

       26
       26
        
               type = types.attrs;

     

       27
       27
        
               default = {};

+1 -1

nixos/modules/services/amqp/rabbitmq.nix

···

       136
       136
        
             };

     

       137
       137
        
       

     

       138
       138
        
             managementPlugin = {

     

       139
       139
       -
               enable = mkEnableOption "the management plugin";

     

       139
       139
       +
               enable = mkEnableOption (lib.mdDoc "the management plugin");

     

       140
       140
        
               port = mkOption {

     

       141
       141
        
                 default = 15672;

     

       142
       142
        
                 type = types.port;

+1 -1

nixos/modules/services/audio/botamusique.nix

···

       12
       12
        
         meta.maintainers = with lib.maintainers; [ hexa ];

     

       13
       13
        
       

     

       14
       14
        
         options.services.botamusique = {

     

       15
       15
       -
           enable = mkEnableOption "botamusique, a bot to play audio streams on mumble";

     

       15
       15
       +
           enable = mkEnableOption (lib.mdDoc "botamusique, a bot to play audio streams on mumble");

     

       16
       16
        
       

     

       17
       17
        
           package = mkOption {

     

       18
       18
        
             type = types.package;

+1 -1

nixos/modules/services/audio/hqplayerd.nix

···

       12
       12
        
       {

     

       13
       13
        
         options = {

     

       14
       14
        
           services.hqplayerd = {

     

       15
       15
       -
             enable = mkEnableOption "HQPlayer Embedded";

     

       15
       15
       +
             enable = mkEnableOption (lib.mdDoc "HQPlayer Embedded");

     

       16
       16
        
       

     

       17
       17
        
             auth = {

     

       18
       18
        
               username = mkOption {

+1 -1

nixos/modules/services/audio/icecast.nix

···

       44
       44
        
       

     

       45
       45
        
           services.icecast = {

     

       46
       46
        
       

     

       47
       47
       -
             enable = mkEnableOption "Icecast server";

     

       47
       47
       +
             enable = mkEnableOption (lib.mdDoc "Icecast server");

     

       48
       48
        
       

     

       49
       49
        
             hostname = mkOption {

     

       50
       50
        
               type = types.nullOr types.str;

+2 -2

nixos/modules/services/audio/jack.nix

···

       16
       16
        
         options = {

     

       17
       17
        
           services.jack = {

     

       18
       18
        
             jackd = {

     

       19
       19
       -
               enable = mkEnableOption ''

     

       19
       19
       +
               enable = mkEnableOption (lib.mdDoc ''

     

       20
       20
        
                 JACK Audio Connection Kit. You need to add yourself to the "jackaudio" group

     

       21
       21
       -
               '';

     

       21
       21
       +
               '');

     

       22
       22
        
       

     

       23
       23
        
               package = mkOption {

     

       24
       24
        
                 # until jack1 promiscuous mode is fixed

+1 -1

nixos/modules/services/audio/jmusicbot.nix

···

       7
       7
        
       {

     

       8
       8
        
         options = {

     

       9
       9
        
           services.jmusicbot = {

     

       10
       10
       -
             enable = mkEnableOption "jmusicbot, a Discord music bot that's easy to set up and run yourself";

     

       10
       10
       +
             enable = mkEnableOption (lib.mdDoc "jmusicbot, a Discord music bot that's easy to set up and run yourself");

     

       11
       11
        
       

     

       12
       12
        
             package = mkOption {

     

       13
       13
        
               type = types.package;

+1 -1

nixos/modules/services/audio/mopidy.nix

···

       26
       26
        
       

     

       27
       27
        
           services.mopidy = {

     

       28
       28
        
       

     

       29
       29
       -
             enable = mkEnableOption "Mopidy, a music player daemon";

     

       29
       29
       +
             enable = mkEnableOption (lib.mdDoc "Mopidy, a music player daemon");

     

       30
       30
        
       

     

       31
       31
        
             dataDir = mkOption {

     

       32
       32
        
               default = "/var/lib/mopidy";

+1 -1

nixos/modules/services/audio/mpdscribble.nix

···

       77
       77
        
       

     

       78
       78
        
         options.services.mpdscribble = {

     

       79
       79
        
       

     

       80
       80
       -
           enable = mkEnableOption "mpdscribble";

     

       80
       80
       +
           enable = mkEnableOption (lib.mdDoc "mpdscribble");

     

       81
       81
        
       

     

       82
       82
        
           proxy = mkOption {

     

       83
       83
        
             default = null;

+1 -1

nixos/modules/services/audio/navidrome.nix

···

       9
       9
        
         options = {

     

       10
       10
        
           services.navidrome = {

     

       11
       11
        
       

     

       12
       12
       -
             enable = mkEnableOption "Navidrome music server";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "Navidrome music server");

     

       13
       13
        
       

     

       14
       14
        
             settings = mkOption rec {

     

       15
       15
        
               type = settingsFormat.type;

+1 -1

nixos/modules/services/audio/networkaudiod.nix

···

       8
       8
        
       in {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.networkaudiod = {

     

       11
       11
       -
             enable = mkEnableOption "Networkaudiod (NAA)";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "Networkaudiod (NAA)");

     

       12
       12
        
           };

     

       13
       13
        
         };

     

       14
       14

+1 -1

nixos/modules/services/audio/roon-bridge.nix

···

       8
       8
        
       in {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.roon-bridge = {

     

       11
       11
       -
             enable = mkEnableOption "Roon Bridge";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "Roon Bridge");

     

       12
       12
        
             openFirewall = mkOption {

     

       13
       13
        
               type = types.bool;

     

       14
       14
        
               default = false;

+1 -1

nixos/modules/services/audio/roon-server.nix

···

       8
       8
        
       in {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.roon-server = {

     

       11
       11
       -
             enable = mkEnableOption "Roon Server";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "Roon Server");

     

       12
       12
        
             openFirewall = mkOption {

     

       13
       13
        
               type = types.bool;

     

       14
       14
        
               default = false;

+1 -1

nixos/modules/services/audio/spotifyd.nix

···

       17
       17
        
       {

     

       18
       18
        
         options = {

     

       19
       19
        
           services.spotifyd = {

     

       20
       20
       -
             enable = mkEnableOption "spotifyd, a Spotify playing daemon";

     

       20
       20
       +
             enable = mkEnableOption (lib.mdDoc "spotifyd, a Spotify playing daemon");

     

       21
       21
        
       

     

       22
       22
        
             config = mkOption {

     

       23
       23
        
               default = "";

+2 -2

nixos/modules/services/audio/squeezelite.nix

···

       14
       14
        
         ###### interface

     

       15
       15
        
       

     

       16
       16
        
         options.services.squeezelite = {

     

       17
       17
       -
           enable = mkEnableOption "Squeezelite, a software Squeezebox emulator";

     

       17
       17
       +
           enable = mkEnableOption (lib.mdDoc "Squeezelite, a software Squeezebox emulator");

     

       18
       18
        
       

     

       19
       19
       -
           pulseAudio = mkEnableOption "pulseaudio support";

     

       19
       19
       +
           pulseAudio = mkEnableOption (lib.mdDoc "pulseaudio support");

     

       20
       20
        
       

     

       21
       21
        
           extraArguments = mkOption {

     

       22
       22
        
             default = "";

+1 -1

nixos/modules/services/audio/ympd.nix

···

       12
       12
        
       

     

       13
       13
        
           services.ympd = {

     

       14
       14
        
       

     

       15
       15
       -
             enable = mkEnableOption "ympd, the MPD Web GUI";

     

       15
       15
       +
             enable = mkEnableOption (lib.mdDoc "ympd, the MPD Web GUI");

     

       16
       16
        
       

     

       17
       17
        
             webPort = mkOption {

     

       18
       18
        
               type = types.either types.str types.port; # string for backwards compat

+1 -1

nixos/modules/services/backup/automysqlbackup.nix

···

       30
       30
        
         options = {

     

       31
       31
        
           services.automysqlbackup = {

     

       32
       32
        
       

     

       33
       33
       -
             enable = mkEnableOption "AutoMySQLBackup";

     

       33
       33
       +
             enable = mkEnableOption (lib.mdDoc "AutoMySQLBackup");

     

       34
       34
        
       

     

       35
       35
        
             calendar = mkOption {

     

       36
       36
        
               type = types.str;

+1 -1

nixos/modules/services/backup/borgmatic.nix

···

       8
       8
        
         cfgfile = settingsFormat.generate "config.yaml" cfg.settings;

     

       9
       9
        
       in {

     

       10
       10
        
         options.services.borgmatic = {

     

       11
       11
       -
           enable = mkEnableOption "borgmatic";

     

       11
       11
       +
           enable = mkEnableOption (lib.mdDoc "borgmatic");

     

       12
       12
        
       

     

       13
       13
        
           settings = mkOption {

     

       14
       14
        
             description = lib.mdDoc ''

+1 -1

nixos/modules/services/backup/duplicati.nix

···

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.duplicati = {

     

       11
       11
       -
             enable = mkEnableOption "Duplicati";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "Duplicati");

     

       12
       12
        
       

     

       13
       13
        
             port = mkOption {

     

       14
       14
        
               default = 8200;

+1 -1

nixos/modules/services/backup/duplicity.nix

···

       13
       13
        
       in

     

       14
       14
        
       {

     

       15
       15
        
         options.services.duplicity = {

     

       16
       16
       -
           enable = mkEnableOption "backups with duplicity";

     

       16
       16
       +
           enable = mkEnableOption (lib.mdDoc "backups with duplicity");

     

       17
       17
        
       

     

       18
       18
        
           root = mkOption {

     

       19
       19
        
             type = types.path;

+1 -1

nixos/modules/services/backup/mysql-backup.nix

···

       37
       37
        
       

     

       38
       38
        
           services.mysqlBackup = {

     

       39
       39
        
       

     

       40
       40
       -
             enable = mkEnableOption "MySQL backups";

     

       40
       40
       +
             enable = mkEnableOption (lib.mdDoc "MySQL backups");

     

       41
       41
        
       

     

       42
       42
        
             calendar = mkOption {

     

       43
       43
        
               type = types.str;

+1 -1

nixos/modules/services/backup/postgresql-backup.nix

···

       71
       71
        
       

     

       72
       72
        
         options = {

     

       73
       73
        
           services.postgresqlBackup = {

     

       74
       74
       -
             enable = mkEnableOption "PostgreSQL dumps";

     

       74
       74
       +
             enable = mkEnableOption (lib.mdDoc "PostgreSQL dumps");

     

       75
       75
        
       

     

       76
       76
        
             startAt = mkOption {

     

       77
       77
        
               default = "*-*-* 01:15:00";

+1 -1

nixos/modules/services/backup/restic-rest-server.nix

···

       9
       9
        
         meta.maintainers = [ maintainers.bachp ];

     

       10
       10
        
       

     

       11
       11
        
         options.services.restic.server = {

     

       12
       12
       -
           enable = mkEnableOption "Restic REST Server";

     

       12
       12
       +
           enable = mkEnableOption (lib.mdDoc "Restic REST Server");

     

       13
       13
        
       

     

       14
       14
        
           listenAddress = mkOption {

     

       15
       15
        
             default = ":8000";

+1 -1

nixos/modules/services/backup/rsnapshot.nix

···

       22
       22
        
       {

     

       23
       23
        
         options = {

     

       24
       24
        
           services.rsnapshot = {

     

       25
       25
       -
             enable = mkEnableOption "rsnapshot backups";

     

       25
       25
       +
             enable = mkEnableOption (lib.mdDoc "rsnapshot backups");

     

       26
       26
        
             enableManualRsnapshot = mkOption {

     

       27
       27
        
               description = lib.mdDoc "Whether to enable manual usage of the rsnapshot command with this module.";

     

       28
       28
        
               default = true;

+1 -1

nixos/modules/services/backup/sanoid.nix

···

       112
       112
        
         # Interface

     

       113
       113
        
       

     

       114
       114
        
         options.services.sanoid = {

     

       115
       115
       -
           enable = mkEnableOption "Sanoid ZFS snapshotting service";

     

       115
       115
       +
           enable = mkEnableOption (lib.mdDoc "Sanoid ZFS snapshotting service");

     

       116
       116
        
       

     

       117
       117
        
           interval = mkOption {

     

       118
       118
        
             type = types.str;

+2 -2

nixos/modules/services/backup/syncoid.nix

···

       85
       85
        
         # Interface

     

       86
       86
        
       

     

       87
       87
        
         options.services.syncoid = {

     

       88
       88
       -
           enable = mkEnableOption "Syncoid ZFS synchronization service";

     

       88
       88
       +
           enable = mkEnableOption (lib.mdDoc "Syncoid ZFS synchronization service");

     

       89
       89
        
       

     

       90
       90
        
           interval = mkOption {

     

       91
       91
        
             type = types.str;

     
···

       200
       200
        
                   '';

     

       201
       201
        
                 };

     

       202
       202
        
       

     

       203
       203
       -
                 recursive = mkEnableOption ''the transfer of child datasets'';

     

       203
       203
       +
                 recursive = mkEnableOption (lib.mdDoc ''the transfer of child datasets'');

     

       204
       204
        
       

     

       205
       205
        
                 sshKey = mkOption {

     

       206
       206
        
                   type = types.nullOr types.path;

+1 -1

nixos/modules/services/backup/tarsnap.nix

···

       30
       30
        
       

     

       31
       31
        
         options = {

     

       32
       32
        
           services.tarsnap = {

     

       33
       33
       -
             enable = mkEnableOption "periodic tarsnap backups";

     

       33
       33
       +
             enable = mkEnableOption (lib.mdDoc "periodic tarsnap backups");

     

       34
       34
        
       

     

       35
       35
        
             keyfile = mkOption {

     

       36
       36
        
               type = types.str;

+3 -3

nixos/modules/services/backup/tsm.nix

···

       8
       8
        
         inherit (lib.types) nonEmptyStr nullOr;

     

       9
       9
        
       

     

       10
       10
        
         options.services.tsmBackup = {

     

       11
       11
       -
           enable = mkEnableOption ''

     

       11
       11
       +
           enable = mkEnableOption (lib.mdDoc ''

     

       12
       12
        
             automatic backups with the

     

       13
       13
        
             IBM Spectrum Protect (Tivoli Storage Manager, TSM) client.

     

       14
       14
        
             This also enables

     

       15
       15
       -
             <option>programs.tsmClient.enable</option>

     

       16
       16
       -
           '';

     

       15
       15
       +
             {option}`programs.tsmClient.enable`

     

       16
       16
       +
           '');

     

       17
       17
        
           command = mkOption {

     

       18
       18
        
             type = nonEmptyStr;

     

       19
       19
        
             default = "backup";

+1 -1

nixos/modules/services/backup/zfs-replication.nix

···

       9
       9
        
       in {

     

       10
       10
        
         options = {

     

       11
       11
        
           services.zfs.autoReplication = {

     

       12
       12
       -
             enable = mkEnableOption "ZFS snapshot replication.";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "ZFS snapshot replication.");

     

       13
       13
        
       

     

       14
       14
        
             followDelete = mkOption {

     

       15
       15
        
               description = lib.mdDoc "Remove remote snapshots that don't have a local correspondant.";

+30 -30

nixos/modules/services/backup/znapzend.nix

···

       294
       294
        
       {

     

       295
       295
        
         options = {

     

       296
       296
        
           services.znapzend = {

     

       297
       297
       -
             enable = mkEnableOption "ZnapZend ZFS backup daemon";

     

       297
       297
       +
             enable = mkEnableOption (lib.mdDoc "ZnapZend ZFS backup daemon");

     

       298
       298
        
       

     

       299
       299
        
             logLevel = mkOption {

     

       300
       300
        
               default = "debug";

     
···

       310
       310
        
               type = str;

     

       311
       311
        
               default = "syslog::daemon";

     

       312
       312
        
               example = "/var/log/znapzend.log";

     

       313
       313
       -
               description = ''

     

       314
       314
       -
                 Where to log to (syslog::&lt;facility&gt; or &lt;filepath&gt;).

     

       313
       313
       +
               description = lib.mdDoc ''

     

       314
       314
       +
                 Where to log to (syslog::\<facility\> or \<filepath\>).

     

       315
       315
        
               '';

     

       316
       316
        
             };

     

       317
       317
        
       

     
···

       358
       358
        
               default = false;

     

       359
       359
        
             };

     

       360
       360
        
       

     

       361
       361
       -
             features.oracleMode = mkEnableOption ''

     

       361
       361
       +
             features.oracleMode = mkEnableOption (lib.mdDoc ''

     

       362
       362
        
               Destroy snapshots one by one instead of using one long argument list.

     

       363
       363
        
               If source and destination are out of sync for a long time, you may have

     

       364
       364
        
               so many snapshots to destroy that the argument gets is too long and the

     

       365
       365
        
               command fails.

     

       366
       366
       -
             '';

     

       367
       367
       -
             features.recvu = mkEnableOption ''

     

       368
       368
       -
               recvu feature which uses <literal>-u</literal> on the receiving end to keep the destination

     

       366
       366
       +
             '');

     

       367
       367
       +
             features.recvu = mkEnableOption (lib.mdDoc ''

     

       368
       368
       +
               recvu feature which uses `-u` on the receiving end to keep the destination

     

       369
       369
        
               filesystem unmounted.

     

       370
       370
       -
             '';

     

       371
       371
       -
             features.compressed = mkEnableOption ''

     

       372
       372
       -
               compressed feature which adds the options <literal>-Lce</literal> to

     

       373
       373
       -
               the <command>zfs send</command> command. When this is enabled, make

     

       370
       370
       +
             '');

     

       371
       371
       +
             features.compressed = mkEnableOption (lib.mdDoc ''

     

       372
       372
       +
               compressed feature which adds the options `-Lce` to

     

       373
       373
       +
               the {command}`zfs send` command. When this is enabled, make

     

       374
       374
        
               sure that both the sending and receiving pool have the same relevant

     

       375
       375
       -
               features enabled. Using <literal>-c</literal> will skip unneccessary

     

       376
       376
       -
               decompress-compress stages, <literal>-L</literal> is for large block

     

       375
       375
       +
               features enabled. Using `-c` will skip unneccessary

     

       376
       376
       +
               decompress-compress stages, `-L` is for large block

     

       377
       377
        
               support and -e is for embedded data support. see

     

       378
       378
       -
               <citerefentry><refentrytitle>znapzend</refentrytitle><manvolnum>1</manvolnum></citerefentry>

     

       379
       379
       -
               and <citerefentry><refentrytitle>zfs</refentrytitle><manvolnum>8</manvolnum></citerefentry>

     

       378
       378
       +
               {manpage}`znapzend(1)`

     

       379
       379
       +
               and {manpage}`zfs(8)`

     

       380
       380
        
               for more info.

     

       381
       381
       -
             '';

     

       382
       382
       -
             features.sendRaw = mkEnableOption ''

     

       383
       383
       -
               sendRaw feature which adds the options <literal>-w</literal> to the

     

       384
       384
       -
               <command>zfs send</command> command. For encrypted source datasets this

     

       381
       381
       +
             '');

     

       382
       382
       +
             features.sendRaw = mkEnableOption (lib.mdDoc ''

     

       383
       383
       +
               sendRaw feature which adds the options `-w` to the

     

       384
       384
       +
               {command}`zfs send` command. For encrypted source datasets this

     

       385
       385
        
               instructs zfs not to decrypt before sending which results in a remote

     

       386
       386
        
               backup that can't be read without the encryption key/passphrase, useful

     

       387
       387
        
               when the remote isn't fully trusted or not physically secure. This

     

       388
       388
        
               option must be used consistently, raw incrementals cannot be based on

     

       389
       389
        
               non-raw snapshots and vice versa.

     

       390
       390
       -
             '';

     

       391
       391
       -
             features.skipIntermediates = mkEnableOption ''

     

       390
       390
       +
             '');

     

       391
       391
       +
             features.skipIntermediates = mkEnableOption (lib.mdDoc ''

     

       392
       392
        
               Enable the skipIntermediates feature to send a single increment

     

       393
       393
        
               between latest common snapshot and the newly made one. It may skip

     

       394
       394
        
               several source snaps if the destination was offline for some time, and

     

       395
       395
        
               it should skip snapshots not managed by znapzend. Normally for online

     

       396
       396
        
               destinations, the new snapshot is sent as soon as it is created on the

     

       397
       397
        
               source, so there are no automatic increments to skip.

     

       398
       398
       -
             '';

     

       399
       399
       -
             features.lowmemRecurse = mkEnableOption ''

     

       398
       398
       +
             '');

     

       399
       399
       +
             features.lowmemRecurse = mkEnableOption (lib.mdDoc ''

     

       400
       400
        
               use lowmemRecurse on systems where you have too many datasets, so a

     

       401
       401
        
               recursive listing of attributes to find backup plans exhausts the

     

       402
       402
       -
               memory available to <command>znapzend</command>: instead, go the slower

     

       402
       402
       +
               memory available to {command}`znapzend`: instead, go the slower

     

       403
       403
        
               way to first list all impacted dataset names, and then query their

     

       404
       404
        
               configs one by one.

     

       405
       405
       -
             '';

     

       406
       406
       -
             features.zfsGetType = mkEnableOption ''

     

       407
       407
       -
               use zfsGetType if your <command>zfs get</command> supports a

     

       408
       408
       -
               <literal>-t</literal> argument for filtering by dataset type at all AND

     

       405
       405
       +
             '');

     

       406
       406
       +
             features.zfsGetType = mkEnableOption (lib.mdDoc ''

     

       407
       407
       +
               use zfsGetType if your {command}`zfs get` supports a

     

       408
       408
       +
               `-t` argument for filtering by dataset type at all AND

     

       409
       409
        
               lists properties for snapshots by default when recursing, so that there

     

       410
       410
        
               is too much data to process while searching for backup plans.

     

       411
       411
        
               If these two conditions apply to your system, the time needed for a

     

       412
       412
       -
               <literal>--recursive</literal> search for backup plans can literally

     

       412
       412
       +
               `--recursive` search for backup plans can literally

     

       413
       413
        
               differ by hundreds of times (depending on the amount of snapshots in

     

       414
       414
        
               that dataset tree... and a decent backup plan will ensure you have a lot

     

       415
       415
        
               of those), so you would benefit from requesting this feature.

     

       416
       416
       -
             '';

     

       416
       416
       +
             '');

     

       417
       417
        
           };

     

       418
       418
        
         };

     

       419
       419

+1 -1

nixos/modules/services/backup/zrepl.nix

···

       11
       11
        
       

     

       12
       12
        
         options = {

     

       13
       13
        
           services.zrepl = {

     

       14
       14
       -
             enable = mkEnableOption "zrepl";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "zrepl");

     

       15
       15
        
       

     

       16
       16
        
             package = mkOption {

     

       17
       17
        
               type = types.package;

+5 -5

nixos/modules/services/blockchain/ethereum/geth.nix

···

       9
       9
        
       

     

       10
       10
        
           options = {

     

       11
       11
        
       

     

       12
       12
       -
             enable = lib.mkEnableOption "Go Ethereum Node";

     

       12
       12
       +
             enable = lib.mkEnableOption (lib.mdDoc "Go Ethereum Node");

     

       13
       13
        
       

     

       14
       14
        
             port = mkOption {

     

       15
       15
        
               type = types.port;

     
···

       18
       18
        
             };

     

       19
       19
        
       

     

       20
       20
        
             http = {

     

       21
       21
       -
               enable = lib.mkEnableOption "Go Ethereum HTTP API";

     

       21
       21
       +
               enable = lib.mkEnableOption (lib.mdDoc "Go Ethereum HTTP API");

     

       22
       22
        
               address = mkOption {

     

       23
       23
        
                 type = types.str;

     

       24
       24
        
                 default = "127.0.0.1";

     
···

       40
       40
        
             };

     

       41
       41
        
       

     

       42
       42
        
             websocket = {

     

       43
       43
       -
               enable = lib.mkEnableOption "Go Ethereum WebSocket API";

     

       43
       43
       +
               enable = lib.mkEnableOption (lib.mdDoc "Go Ethereum WebSocket API");

     

       44
       44
        
               address = mkOption {

     

       45
       45
        
                 type = types.str;

     

       46
       46
        
                 default = "127.0.0.1";

     
···

       62
       62
        
             };

     

       63
       63
        
       

     

       64
       64
        
             authrpc = {

     

       65
       65
       -
               enable = lib.mkEnableOption "Go Ethereum Auth RPC API";

     

       65
       65
       +
               enable = lib.mkEnableOption (lib.mdDoc "Go Ethereum Auth RPC API");

     

       66
       66
        
               address = mkOption {

     

       67
       67
        
                 type = types.str;

     

       68
       68
        
                 default = "127.0.0.1";

     
···

       91
       91
        
             };

     

       92
       92
        
       

     

       93
       93
        
             metrics = {

     

       94
       94
       -
               enable = lib.mkEnableOption "Go Ethereum prometheus metrics";

     

       94
       94
       +
               enable = lib.mkEnableOption (lib.mdDoc "Go Ethereum prometheus metrics");

     

       95
       95
        
               address = mkOption {

     

       96
       96
        
                 type = types.str;

     

       97
       97
        
                 default = "127.0.0.1";

+1 -1

nixos/modules/services/cluster/corosync/default.nix

···

       7
       7
        
       {

     

       8
       8
        
         # interface

     

       9
       9
        
         options.services.corosync = {

     

       10
       10
       -
           enable = mkEnableOption "corosync";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "corosync");

     

       11
       11
        
       

     

       12
       12
        
           package = mkOption {

     

       13
       13
        
             type = types.package;

+1 -1

nixos/modules/services/cluster/hadoop/default.nix

···

       197
       197
        
             description = lib.mdDoc "Directories containing additional config files to be added to HADOOP_CONF_DIR";

     

       198
       198
        
           };

     

       199
       199
        
       

     

       200
       200
       -
           gatewayRole.enable = mkEnableOption "gateway role for deploying hadoop configs";

     

       200
       200
       +
           gatewayRole.enable = mkEnableOption (lib.mdDoc "gateway role for deploying hadoop configs");

     

       201
       201
        
       

     

       202
       202
        
           package = mkOption {

     

       203
       203
        
             type = types.package;

+4 -4

nixos/modules/services/cluster/hadoop/hbase.nix

···

       9
       9
        
       {

     

       10
       10
        
         options.services.hadoop = {

     

       11
       11
        
       

     

       12
       12
       -
           gatewayRole.enableHbaseCli = mkEnableOption "HBase CLI tools";

     

       12
       12
       +
           gatewayRole.enableHbaseCli = mkEnableOption (lib.mdDoc "HBase CLI tools");

     

       13
       13
        
       

     

       14
       14
        
           hbaseSiteDefault = mkOption {

     

       15
       15
        
             default = {

     
···

       77
       77
        
               default = null;

     

       78
       78
        
             };

     

       79
       79
        
             master = {

     

       80
       80
       -
               enable = mkEnableOption "HBase Master";

     

       81
       81
       -
               initHDFS = mkEnableOption "initialization of the hbase directory on HDFS";

     

       80
       80
       +
               enable = mkEnableOption (lib.mdDoc "HBase Master");

     

       81
       81
       +
               initHDFS = mkEnableOption (lib.mdDoc "initialization of the hbase directory on HDFS");

     

       82
       82
        
       

     

       83
       83
        
               openFirewall = mkOption {

     

       84
       84
        
                 type = types.bool;

     
···

       89
       89
        
               };

     

       90
       90
        
             };

     

       91
       91
        
             regionServer = {

     

       92
       92
       -
               enable = mkEnableOption "HBase RegionServer";

     

       92
       92
       +
               enable = mkEnableOption (lib.mdDoc "HBase RegionServer");

     

       93
       93
        
       

     

       94
       94
        
               overrideHosts = mkOption {

     

       95
       95
        
                 type = types.bool;

+1 -1

nixos/modules/services/cluster/hadoop/hdfs.nix

···

       8
       8
        
       

     

       9
       9
        
         # Generator for HDFS service options

     

       10
       10
        
         hadoopServiceOption = { serviceName, firewallOption ? true, extraOpts ? null }: {

     

       11
       11
       -
           enable = mkEnableOption serviceName;

     

       11
       11
       +
           enable = mkEnableOption (lib.mdDoc serviceName);

     

       12
       12
        
           restartIfChanged = mkOption {

     

       13
       13
        
             type = types.bool;

     

       14
       14
        
             description = lib.mdDoc ''

+2 -2

nixos/modules/services/cluster/hadoop/yarn.nix

···

       31
       31
        
       {

     

       32
       32
        
         options.services.hadoop.yarn = {

     

       33
       33
        
           resourcemanager = {

     

       34
       34
       -
             enable = mkEnableOption "Hadoop YARN ResourceManager";

     

       34
       34
       +
             enable = mkEnableOption (lib.mdDoc "Hadoop YARN ResourceManager");

     

       35
       35
        
             inherit restartIfChanged extraFlags extraEnv;

     

       36
       36
        
       

     

       37
       37
        
             openFirewall = mkOption {

     
···

       43
       43
        
             };

     

       44
       44
        
           };

     

       45
       45
        
           nodemanager = {

     

       46
       46
       -
             enable = mkEnableOption "Hadoop YARN NodeManager";

     

       46
       46
       +
             enable = mkEnableOption (lib.mdDoc "Hadoop YARN NodeManager");

     

       47
       47
        
             inherit restartIfChanged extraFlags extraEnv;

     

       48
       48
        
       

     

       49
       49
        
             resource = {

+1 -1

nixos/modules/services/cluster/k3s/default.nix

···

       13
       13
        
       

     

       14
       14
        
         # interface

     

       15
       15
        
         options.services.k3s = {

     

       16
       16
       -
           enable = mkEnableOption "k3s";

     

       16
       16
       +
           enable = mkEnableOption (lib.mdDoc "k3s");

     

       17
       17
        
       

     

       18
       18
        
           package = mkOption {

     

       19
       19
        
             type = types.package;

+1 -1

nixos/modules/services/cluster/kubernetes/addon-manager.nix

···

       62
       62
        
             '';

     

       63
       63
        
           };

     

       64
       64
        
       

     

       65
       65
       -
           enable = mkEnableOption "Kubernetes addon manager.";

     

       65
       65
       +
           enable = mkEnableOption (lib.mdDoc "Kubernetes addon manager.");

     

       66
       66
        
         };

     

       67
       67
        
       

     

       68
       68
        
         ###### implementation

+1 -1

nixos/modules/services/cluster/kubernetes/addons/dns.nix

···

       12
       12
        
         };

     

       13
       13
        
       in {

     

       14
       14
        
         options.services.kubernetes.addons.dns = {

     

       15
       15
       -
           enable = mkEnableOption "kubernetes dns addon";

     

       15
       15
       +
           enable = mkEnableOption (lib.mdDoc "kubernetes dns addon");

     

       16
       16
        
       

     

       17
       17
        
           clusterIp = mkOption {

     

       18
       18
        
             description = lib.mdDoc "Dns addon clusterIP";

+1 -1

nixos/modules/services/cluster/kubernetes/apiserver.nix

···

       98
       98
        
             type = listOf str;

     

       99
       99
        
           };

     

       100
       100
        
       

     

       101
       101
       -
           enable = mkEnableOption "Kubernetes apiserver";

     

       101
       101
       +
           enable = mkEnableOption (lib.mdDoc "Kubernetes apiserver");

     

       102
       102
        
       

     

       103
       103
        
           enableAdmissionPlugins = mkOption {

     

       104
       104
        
             description = lib.mdDoc ''

+1 -1

nixos/modules/services/cluster/kubernetes/controller-manager.nix

···

       35
       35
        
             type = str;

     

       36
       36
        
           };

     

       37
       37
        
       

     

       38
       38
       -
           enable = mkEnableOption "Kubernetes controller manager";

     

       38
       38
       +
           enable = mkEnableOption (lib.mdDoc "Kubernetes controller manager");

     

       39
       39
        
       

     

       40
       40
        
           extraOpts = mkOption {

     

       41
       41
        
             description = lib.mdDoc "Kubernetes controller manager extra command line options.";

+1 -1

nixos/modules/services/cluster/kubernetes/flannel.nix

···

       12
       12
        
       {

     

       13
       13
        
         ###### interface

     

       14
       14
        
         options.services.kubernetes.flannel = {

     

       15
       15
       -
           enable = mkEnableOption "enable flannel networking";

     

       15
       15
       +
           enable = mkEnableOption (lib.mdDoc "enable flannel networking");

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
        
         ###### implementation

+1 -1

nixos/modules/services/cluster/kubernetes/kubelet.nix

···

       145
       145
        
             default = "unix:///run/containerd/containerd.sock";

     

       146
       146
        
           };

     

       147
       147
        
       

     

       148
       148
       -
           enable = mkEnableOption "Kubernetes kubelet.";

     

       148
       148
       +
           enable = mkEnableOption (lib.mdDoc "Kubernetes kubelet.");

     

       149
       149
        
       

     

       150
       150
        
           extraOpts = mkOption {

     

       151
       151
        
             description = lib.mdDoc "Kubernetes kubelet extra command line options.";

+3 -3

nixos/modules/services/cluster/kubernetes/pki.nix

···

       41
       41
        
         ###### interface

     

       42
       42
        
         options.services.kubernetes.pki = with lib.types; {

     

       43
       43
        
       

     

       44
       44
       -
           enable = mkEnableOption "easyCert issuer service";

     

       44
       44
       +
           enable = mkEnableOption (lib.mdDoc "easyCert issuer service");

     

       45
       45
        
       

     

       46
       46
        
           certs = mkOption {

     

       47
       47
        
             description = lib.mdDoc "List of certificate specs to feed to cert generator.";

     
···

       114
       114
        
           };

     

       115
       115
        
       

     

       116
       116
        
           etcClusterAdminKubeconfig = mkOption {

     

       117
       117
       -
             description = ''

     

       117
       117
       +
             description = lib.mdDoc ''

     

       118
       118
        
               Symlink a kubeconfig with cluster-admin privileges to environment path

     

       119
       119
       -
               (/etc/&lt;path&gt;).

     

       119
       119
       +
               (/etc/\<path\>).

     

       120
       120
        
             '';

     

       121
       121
        
             default = null;

     

       122
       122
        
             type = nullOr str;

+1 -1

nixos/modules/services/cluster/kubernetes/proxy.nix

···

       21
       21
        
             type = str;

     

       22
       22
        
           };

     

       23
       23
        
       

     

       24
       24
       -
           enable = mkEnableOption "Kubernetes proxy";

     

       24
       24
       +
           enable = mkEnableOption (lib.mdDoc "Kubernetes proxy");

     

       25
       25
        
       

     

       26
       26
        
           extraOpts = mkOption {

     

       27
       27
        
             description = lib.mdDoc "Kubernetes proxy extra command line options.";

+1 -1

nixos/modules/services/cluster/kubernetes/scheduler.nix

···

       17
       17
        
             type = str;

     

       18
       18
        
           };

     

       19
       19
        
       

     

       20
       20
       -
           enable = mkEnableOption "Kubernetes scheduler";

     

       20
       20
       +
           enable = mkEnableOption (lib.mdDoc "Kubernetes scheduler");

     

       21
       21
        
       

     

       22
       22
        
           extraOpts = mkOption {

     

       23
       23
        
             description = lib.mdDoc "Kubernetes scheduler extra command line options.";

+1 -1

nixos/modules/services/cluster/pacemaker/default.nix

···

       7
       7
        
       {

     

       8
       8
        
         # interface

     

       9
       9
        
         options.services.pacemaker = {

     

       10
       10
       -
           enable = mkEnableOption "pacemaker";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "pacemaker");

     

       11
       11
        
       

     

       12
       12
        
           package = mkOption {

     

       13
       13
        
             type = types.package;

+1 -1

nixos/modules/services/cluster/patroni/default.nix

···

       15
       15
        
       {

     

       16
       16
        
         options.services.patroni = {

     

       17
       17
        
       

     

       18
       18
       -
           enable = mkEnableOption "Patroni";

     

       18
       18
       +
           enable = mkEnableOption (lib.mdDoc "Patroni");

     

       19
       19
        
       

     

       20
       20
        
           postgresqlPackage = mkOption {

     

       21
       21
        
             type = types.package;

+2 -2

nixos/modules/services/cluster/spark/default.nix

···

       7
       7
        
         options = {

     

       8
       8
        
           services.spark = {

     

       9
       9
        
             master = {

     

       10
       10
       -
               enable = mkEnableOption "Spark master service";

     

       10
       10
       +
               enable = mkEnableOption (lib.mdDoc "Spark master service");

     

       11
       11
        
               bind = mkOption {

     

       12
       12
        
                 type = types.str;

     

       13
       13
        
                 description = lib.mdDoc "Address the spark master binds to.";

     
···

       35
       35
        
               };

     

       36
       36
        
             };

     

       37
       37
        
             worker = {

     

       38
       38
       -
               enable = mkEnableOption "Spark worker service";

     

       38
       38
       +
               enable = mkEnableOption (lib.mdDoc "Spark worker service");

     

       39
       39
        
               workDir = mkOption {

     

       40
       40
        
                 type = types.path;

     

       41
       41
        
                 description = lib.mdDoc "Spark worker work dir.";

+3 -3

nixos/modules/services/computing/boinc/client.nix

···

       47
       47
        
             allowRemoteGuiRpc = mkOption {

     

       48
       48
        
               type = types.bool;

     

       49
       49
        
               default = false;

     

       50
       50
       -
               description = ''

     

       50
       50
       +
               description = lib.mdDoc ''

     

       51
       51
        
                 If set to true, any remote host can connect to and control this BOINC

     

       52
       52
        
                 client (subject to password authentication). If instead set to false,

     

       53
       53
       -
                 only the hosts listed in <varname>dataDir</varname>/remote_hosts.cfg will be allowed to

     

       53
       53
       +
                 only the hosts listed in {var}`dataDir`/remote_hosts.cfg will be allowed to

     

       54
       54
        
                 connect.

     

       55
       55
        
       

     

       56
       56
       -
                 See also: <link xlink:href="http://boinc.berkeley.edu/wiki/Controlling_BOINC_remotely#Remote_access"/>

     

       56
       56
       +
                 See also: <http://boinc.berkeley.edu/wiki/Controlling_BOINC_remotely#Remote_access>

     

       57
       57
        
               '';

     

       58
       58
        
             };

     

       59
       59

+1 -1

nixos/modules/services/computing/foldingathome/client.nix

···

       18
       18
        
           '')

     

       19
       19
        
         ];

     

       20
       20
        
         options.services.foldingathome = {

     

       21
       21
       -
           enable = mkEnableOption "Enable the Folding@home client";

     

       21
       21
       +
           enable = mkEnableOption (lib.mdDoc "Enable the Folding@home client");

     

       22
       22
        
       

     

       23
       23
        
           package = mkOption {

     

       24
       24
        
             type = types.package;

+2 -2

nixos/modules/services/computing/slurm/slurm.nix

···

       76
       76
        
             };

     

       77
       77
        
       

     

       78
       78
        
             dbdserver = {

     

       79
       79
       -
               enable = mkEnableOption "SlurmDBD service";

     

       79
       79
       +
               enable = mkEnableOption (lib.mdDoc "SlurmDBD service");

     

       80
       80
        
       

     

       81
       81
        
               dbdHost = mkOption {

     

       82
       82
        
                 type = types.str;

     
···

       117
       117
        
             };

     

       118
       118
        
       

     

       119
       119
        
             client = {

     

       120
       120
       -
               enable = mkEnableOption "slurm client daemon";

     

       120
       120
       +
               enable = mkEnableOption (lib.mdDoc "slurm client daemon");

     

       121
       121
        
             };

     

       122
       122
        
       

     

       123
       123
        
             enableStools = mkOption {

+1 -1

nixos/modules/services/computing/torque/mom.nix

···

       17
       17
        
         options = {

     

       18
       18
        
       

     

       19
       19
        
           services.torque.mom = {

     

       20
       20
       -
             enable = mkEnableOption "torque computing node";

     

       20
       20
       +
             enable = mkEnableOption (lib.mdDoc "torque computing node");

     

       21
       21
        
       

     

       22
       22
        
             serverNode = mkOption {

     

       23
       23
        
               type = types.str;

+1 -1

nixos/modules/services/computing/torque/server.nix

···

       11
       11
        
       

     

       12
       12
        
           services.torque.server = {

     

       13
       13
        
       

     

       14
       14
       -
             enable = mkEnableOption "torque server";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "torque server");

     

       15
       15
        
       

     

       16
       16
        
           };

     

       17
       17

+1 -1

nixos/modules/services/continuous-integration/gitlab-runner.nix

···

       109
       109
        
       in

     

       110
       110
        
       {

     

       111
       111
        
         options.services.gitlab-runner = {

     

       112
       112
       -
           enable = mkEnableOption "Gitlab Runner";

     

       112
       112
       +
           enable = mkEnableOption (lib.mdDoc "Gitlab Runner");

     

       113
       113
        
           configFile = mkOption {

     

       114
       114
        
             type = types.nullOr types.path;

     

       115
       115
        
             default = null;

+1 -1

nixos/modules/services/continuous-integration/gocd-agent/default.nix

···

       8
       8
        
       in {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.gocd-agent = {

     

       11
       11
       -
             enable = mkEnableOption "gocd-agent";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "gocd-agent");

     

       12
       12
        
       

     

       13
       13
        
             user = mkOption {

     

       14
       14
        
               default = "gocd-agent";

+1 -1

nixos/modules/services/continuous-integration/gocd-server/default.nix

···

       8
       8
        
       in {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.gocd-server = {

     

       11
       11
       -
             enable = mkEnableOption "gocd-server";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "gocd-server");

     

       12
       12
        
       

     

       13
       13
        
             user = mkOption {

     

       14
       14
        
               default = "gocd-server";

+1 -1

nixos/modules/services/databases/aerospike.nix

···

       39
       39
        
         options = {

     

       40
       40
        
       

     

       41
       41
        
           services.aerospike = {

     

       42
       42
       -
             enable = mkEnableOption "Aerospike server";

     

       42
       42
       +
             enable = mkEnableOption (lib.mdDoc "Aerospike server");

     

       43
       43
        
       

     

       44
       44
        
             package = mkOption {

     

       45
       45
        
               default = pkgs.aerospike;

+2 -2

nixos/modules/services/databases/cassandra.nix

···

       101
       101
        
       {

     

       102
       102
        
         options.services.cassandra = {

     

       103
       103
        
       

     

       104
       104
       -
           enable = mkEnableOption ''

     

       104
       104
       +
           enable = mkEnableOption (lib.mdDoc ''

     

       105
       105
        
             Apache Cassandra – Scalable and highly available database.

     

       106
       106
       -
           '';

     

       106
       106
       +
           '');

     

       107
       107
        
       

     

       108
       108
        
           clusterName = mkOption {

     

       109
       109
        
             type = types.str;

+1 -1

nixos/modules/services/databases/clickhouse.nix

···

       11
       11
        
       

     

       12
       12
        
           services.clickhouse = {

     

       13
       13
        
       

     

       14
       14
       -
             enable = mkEnableOption "ClickHouse database server";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "ClickHouse database server");

     

       15
       15
        
       

     

       16
       16
        
             package = mkOption {

     

       17
       17
        
               type = types.package;

+1 -1

nixos/modules/services/databases/cockroachdb.nix

···

       49
       49
        
       {

     

       50
       50
        
         options = {

     

       51
       51
        
           services.cockroachdb = {

     

       52
       52
       -
             enable = mkEnableOption "CockroachDB Server";

     

       52
       52
       +
             enable = mkEnableOption (lib.mdDoc "CockroachDB Server");

     

       53
       53
        
       

     

       54
       54
        
             listen = addressOption "intra-cluster communication" 26257;

     

       55
       55

+1 -1

nixos/modules/services/databases/dgraph.nix

···

       53
       53
        
       {

     

       54
       54
        
         options = {

     

       55
       55
        
           services.dgraph = {

     

       56
       56
       -
             enable = mkEnableOption "Dgraph native GraphQL database with a graph backend";

     

       56
       56
       +
             enable = mkEnableOption (lib.mdDoc "Dgraph native GraphQL database with a graph backend");

     

       57
       57
        
       

     

       58
       58
        
             package = lib.mkPackageOption pkgs "dgraph" { };

     

       59
       59

+1 -1

nixos/modules/services/databases/dragonflydb.nix

···

       25
       25
        
       

     

       26
       26
        
         options = {

     

       27
       27
        
           services.dragonflydb = {

     

       28
       28
       -
             enable = mkEnableOption "DragonflyDB";

     

       28
       28
       +
             enable = mkEnableOption (lib.mdDoc "DragonflyDB");

     

       29
       29
        
       

     

       30
       30
        
             user = mkOption {

     

       31
       31
        
               type = types.str;

+1 -1

nixos/modules/services/databases/firebird.nix

···

       40
       40
        
       

     

       41
       41
        
           services.firebird = {

     

       42
       42
        
       

     

       43
       43
       -
             enable = mkEnableOption "the Firebird super server";

     

       43
       43
       +
             enable = mkEnableOption (lib.mdDoc "the Firebird super server");

     

       44
       44
        
       

     

       45
       45
        
             package = mkOption {

     

       46
       46
        
               default = pkgs.firebird;

+1 -1

nixos/modules/services/databases/foundationdb.nix

···

       62
       62
        
       {

     

       63
       63
        
         options.services.foundationdb = {

     

       64
       64
        
       

     

       65
       65
       -
           enable = mkEnableOption "FoundationDB Server";

     

       65
       65
       +
           enable = mkEnableOption (lib.mdDoc "FoundationDB Server");

     

       66
       66
        
       

     

       67
       67
        
           package = mkOption {

     

       68
       68
        
             type        = types.package;

+2 -2

nixos/modules/services/databases/hbase-standalone.nix

···

       41
       41
        
         options = {

     

       42
       42
        
           services.hbase-standalone = {

     

       43
       43
        
       

     

       44
       44
       -
             enable = mkEnableOption ''

     

       44
       44
       +
             enable = mkEnableOption (lib.mdDoc ''

     

       45
       45
        
               HBase master in standalone mode with embedded regionserver and zookeper.

     

       46
       46
        
               Do not use this configuration for production nor for evaluating HBase performance.

     

       47
       47
       -
             '';

     

       47
       47
       +
             '');

     

       48
       48
        
       

     

       49
       49
        
             package = mkOption {

     

       50
       50
        
               type = types.package;

+1 -1

nixos/modules/services/databases/influxdb2.nix

···

       10
       10
        
       {

     

       11
       11
        
         options = {

     

       12
       12
        
           services.influxdb2 = {

     

       13
       13
       -
             enable = mkEnableOption "the influxdb2 server";

     

       13
       13
       +
             enable = mkEnableOption (lib.mdDoc "the influxdb2 server");

     

       14
       14
        
       

     

       15
       15
        
             package = mkOption {

     

       16
       16
        
               default = pkgs.influxdb2-server;

+2 -2

nixos/modules/services/databases/memcached.nix

···

       17
       17
        
         options = {

     

       18
       18
        
       

     

       19
       19
        
           services.memcached = {

     

       20
       20
       -
             enable = mkEnableOption "Memcached";

     

       20
       20
       +
             enable = mkEnableOption (lib.mdDoc "Memcached");

     

       21
       21
        
       

     

       22
       22
        
             user = mkOption {

     

       23
       23
        
               type = types.str;

     
···

       37
       37
        
               description = lib.mdDoc "The port to bind to.";

     

       38
       38
        
             };

     

       39
       39
        
       

     

       40
       40
       -
             enableUnixSocket = mkEnableOption "unix socket at /run/memcached/memcached.sock";

     

       40
       40
       +
             enableUnixSocket = mkEnableOption (lib.mdDoc "unix socket at /run/memcached/memcached.sock");

     

       41
       41
        
       

     

       42
       42
        
             maxMemory = mkOption {

     

       43
       43
        
               type = types.ints.unsigned;

+1 -1

nixos/modules/services/databases/monetdb.nix

···

       12
       12
        
         options = {

     

       13
       13
        
           services.monetdb = {

     

       14
       14
        
       

     

       15
       15
       -
             enable = mkEnableOption "the MonetDB database server";

     

       15
       15
       +
             enable = mkEnableOption (lib.mdDoc "the MonetDB database server");

     

       16
       16
        
       

     

       17
       17
        
             package = mkOption {

     

       18
       18
        
               type = types.package;

+1 -1

nixos/modules/services/databases/mongodb.nix

···

       29
       29
        
       

     

       30
       30
        
           services.mongodb = {

     

       31
       31
        
       

     

       32
       32
       -
             enable = mkEnableOption "the MongoDB server";

     

       32
       32
       +
             enable = mkEnableOption (lib.mdDoc "the MongoDB server");

     

       33
       33
        
       

     

       34
       34
        
             package = mkOption {

     

       35
       35
        
               default = pkgs.mongodb;

+1 -1

nixos/modules/services/databases/mysql.nix

···

       31
       31
        
       

     

       32
       32
        
           services.mysql = {

     

       33
       33
        
       

     

       34
       34
       -
             enable = mkEnableOption "MySQL server";

     

       34
       34
       +
             enable = mkEnableOption (lib.mdDoc "MySQL server");

     

       35
       35
        
       

     

       36
       36
        
             package = mkOption {

     

       37
       37
        
               type = types.package;

+2 -2

nixos/modules/services/databases/neo4j.nix

···

       333
       333
        
             enable = mkOption {

     

       334
       334
        
               type = types.bool;

     

       335
       335
        
               default = true;

     

       336
       336
       -
               description = ''

     

       336
       336
       +
               description = lib.mdDoc ''

     

       337
       337
        
                 Enable the HTTP connector for Neo4j. Setting this option to

     

       338
       338
       -
                 <literal>false</literal> will stop Neo4j from listening for incoming

     

       338
       338
       +
                 `false` will stop Neo4j from listening for incoming

     

       339
       339
        
                 connections on the HTTPS port (7474 by default).

     

       340
       340
        
               '';

     

       341
       341
        
             };

+1 -1

nixos/modules/services/databases/pgmanage.nix

···

       44
       44
        
       in {

     

       45
       45
        
       

     

       46
       46
        
         options.services.pgmanage = {

     

       47
       47
       -
           enable = mkEnableOption "PostgreSQL Administration for the web";

     

       47
       47
       +
           enable = mkEnableOption (lib.mdDoc "PostgreSQL Administration for the web");

     

       48
       48
        
       

     

       49
       49
        
           package = mkOption {

     

       50
       50
        
             type = types.package;

+1 -1

nixos/modules/services/databases/postgresql.nix

···

       40
       40
        
       

     

       41
       41
        
           services.postgresql = {

     

       42
       42
        
       

     

       43
       43
       -
             enable = mkEnableOption "PostgreSQL Server";

     

       43
       43
       +
             enable = mkEnableOption (lib.mdDoc "PostgreSQL Server");

     

       44
       44
        
       

     

       45
       45
        
             package = mkOption {

     

       46
       46
        
               type = types.package;

+4 -4

nixos/modules/services/databases/redis.nix

···

       61
       61
        
               description = lib.mdDoc "Which Redis derivation to use.";

     

       62
       62
        
             };

     

       63
       63
        
       

     

       64
       64
       -
             vmOverCommit = mkEnableOption ''

     

       64
       64
       +
             vmOverCommit = mkEnableOption (lib.mdDoc ''

     

       65
       65
        
               setting of vm.overcommit_memory to 1

     

       66
       66
        
               (Suggested for Background Saving: http://redis.io/topics/faq)

     

       67
       67
       -
             '';

     

       67
       67
       +
             '');

     

       68
       68
        
       

     

       69
       69
        
             servers = mkOption {

     

       70
       70
        
               type = with types; attrsOf (submodule ({config, name, ...}@args: {

     

       71
       71
        
                 options = {

     

       72
       72
       -
                   enable = mkEnableOption ''

     

       72
       72
       +
                   enable = mkEnableOption (lib.mdDoc ''

     

       73
       73
        
                     Redis server.

     

       74
       74
        
       

     

       75
       75
        
                     Note that the NixOS module for Redis disables kernel support

     

       76
       76
        
                     for Transparent Huge Pages (THP),

     

       77
       77
        
                     because this features causes major performance problems for Redis,

     

       78
       78
        
                     e.g. (https://redis.io/topics/latency).

     

       79
       79
       -
                   '';

     

       79
       79
       +
                   '');

     

       80
       80
        
       

     

       81
       81
        
                   user = mkOption {

     

       82
       82
        
                     type = types.str;

+1 -1

nixos/modules/services/databases/rethinkdb.nix

···

       15
       15
        
       

     

       16
       16
        
           services.rethinkdb = {

     

       17
       17
        
       

     

       18
       18
       -
             enable = mkEnableOption "RethinkDB server";

     

       18
       18
       +
             enable = mkEnableOption (lib.mdDoc "RethinkDB server");

     

       19
       19
        
       

     

       20
       20
        
             #package = mkOption {

     

       21
       21
        
             #  default = pkgs.rethinkdb;

+1 -1

nixos/modules/services/databases/victoriametrics.nix

···

       2
       2
        
       let cfg = config.services.victoriametrics; in

     

       3
       3
        
       {

     

       4
       4
        
         options.services.victoriametrics = with lib; {

     

       5
       5
       -
           enable = mkEnableOption "victoriametrics";

     

       5
       5
       +
           enable = mkEnableOption (lib.mdDoc "victoriametrics");

     

       6
       6
        
           package = mkOption {

     

       7
       7
        
             type = types.package;

     

       8
       8
        
             default = pkgs.victoriametrics;

+1 -1

nixos/modules/services/desktops/bamf.nix

···

       13
       13
        
       

     

       14
       14
        
         options = {

     

       15
       15
        
           services.bamf = {

     

       16
       16
       -
             enable = mkEnableOption "bamf";

     

       16
       16
       +
             enable = mkEnableOption (lib.mdDoc "bamf");

     

       17
       17
        
           };

     

       18
       18
        
         };

     

       19
       19

+1 -1

nixos/modules/services/desktops/blueman.nix

···

       9
       9
        
         ###### interface

     

       10
       10
        
         options = {

     

       11
       11
        
           services.blueman = {

     

       12
       12
       -
             enable = mkEnableOption "blueman";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "blueman");

     

       13
       13
        
           };

     

       14
       14
        
         };

     

       15
       15

+1 -1

nixos/modules/services/desktops/flatpak.nix

···

       14
       14
        
         ###### interface

     

       15
       15
        
         options = {

     

       16
       16
        
           services.flatpak = {

     

       17
       17
       -
             enable = mkEnableOption "flatpak";

     

       17
       17
       +
             enable = mkEnableOption (lib.mdDoc "flatpak");

     

       18
       18
        
           };

     

       19
       19
        
         };

     

       20
       20

+2 -2

nixos/modules/services/desktops/gnome/chrome-gnome-shell.nix

···

       18
       18
        
       

     

       19
       19
        
         ###### interface

     

       20
       20
        
         options = {

     

       21
       21
       -
           services.gnome.chrome-gnome-shell.enable = mkEnableOption ''

     

       21
       21
       +
           services.gnome.chrome-gnome-shell.enable = mkEnableOption (lib.mdDoc ''

     

       22
       22
        
             Chrome GNOME Shell native host connector, a DBus service

     

       23
       23
        
             allowing to install GNOME Shell extensions from a web browser.

     

       24
       24
       -
           '';

     

       24
       24
       +
           '');

     

       25
       25
        
         };

     

       26
       26
        
       

     

       27
       27

+2 -2

nixos/modules/services/desktops/gnome/evolution-data-server.nix

···

       27
       27
        
         options = {

     

       28
       28
        
       

     

       29
       29
        
           services.gnome.evolution-data-server = {

     

       30
       30
       -
             enable = mkEnableOption "Evolution Data Server, a collection of services for storing addressbooks and calendars.";

     

       30
       30
       +
             enable = mkEnableOption (lib.mdDoc "Evolution Data Server, a collection of services for storing addressbooks and calendars.");

     

       31
       31
        
             plugins = mkOption {

     

       32
       32
        
               type = types.listOf types.package;

     

       33
       33
        
               default = [ ];

     
···

       35
       35
        
             };

     

       36
       36
        
           };

     

       37
       37
        
           programs.evolution = {

     

       38
       38
       -
             enable = mkEnableOption "Evolution, a Personal information management application that provides integrated mail, calendaring and address book functionality.";

     

       38
       38
       +
             enable = mkEnableOption (lib.mdDoc "Evolution, a Personal information management application that provides integrated mail, calendaring and address book functionality.");

     

       39
       39
        
             plugins = mkOption {

     

       40
       40
        
               type = types.listOf types.package;

     

       41
       41
        
               default = [ ];

+1 -1

nixos/modules/services/desktops/gnome/glib-networking.nix

···

       24
       24
        
       

     

       25
       25
        
           services.gnome.glib-networking = {

     

       26
       26
        
       

     

       27
       27
       -
             enable = mkEnableOption "network extensions for GLib";

     

       27
       27
       +
             enable = mkEnableOption (lib.mdDoc "network extensions for GLib");

     

       28
       28
        
       

     

       29
       29
        
           };

     

       30
       30

+1 -1

nixos/modules/services/desktops/gnome/gnome-initial-setup.nix

···

       62
       62
        
       

     

       63
       63
        
           services.gnome.gnome-initial-setup = {

     

       64
       64
        
       

     

       65
       65
       -
             enable = mkEnableOption "GNOME Initial Setup, a Simple, easy, and safe way to prepare a new system";

     

       65
       65
       +
             enable = mkEnableOption (lib.mdDoc "GNOME Initial Setup, a Simple, easy, and safe way to prepare a new system");

     

       66
       66
        
       

     

       67
       67
        
           };

     

       68
       68

+1 -1

nixos/modules/services/desktops/gnome/gnome-remote-desktop.nix

···

       19
       19
        
         ###### interface

     

       20
       20
        
         options = {

     

       21
       21
        
           services.gnome.gnome-remote-desktop = {

     

       22
       22
       -
             enable = mkEnableOption "Remote Desktop support using Pipewire";

     

       22
       22
       +
             enable = mkEnableOption (lib.mdDoc "Remote Desktop support using Pipewire");

     

       23
       23
        
           };

     

       24
       24
        
         };

     

       25
       25

+1 -1

nixos/modules/services/desktops/gnome/gnome-settings-daemon.nix

···

       34
       34
        
       

     

       35
       35
        
           services.gnome.gnome-settings-daemon = {

     

       36
       36
        
       

     

       37
       37
       -
             enable = mkEnableOption "GNOME Settings Daemon";

     

       37
       37
       +
             enable = mkEnableOption (lib.mdDoc "GNOME Settings Daemon");

     

       38
       38
        
       

     

       39
       39
        
           };

     

       40
       40

+1 -1

nixos/modules/services/desktops/gnome/gnome-user-share.nix

···

       24
       24
        
       

     

       25
       25
        
           services.gnome.gnome-user-share = {

     

       26
       26
        
       

     

       27
       27
       -
             enable = mkEnableOption "GNOME User Share, a user-level file sharing service for GNOME";

     

       27
       27
       +
             enable = mkEnableOption (lib.mdDoc "GNOME User Share, a user-level file sharing service for GNOME");

     

       28
       28
        
       

     

       29
       29
        
           };

     

       30
       30

+1 -1

nixos/modules/services/desktops/gvfs.nix

···

       29
       29
        
       

     

       30
       30
        
           services.gvfs = {

     

       31
       31
        
       

     

       32
       32
       -
             enable = mkEnableOption "GVfs, a userspace virtual filesystem";

     

       32
       32
       +
             enable = mkEnableOption (lib.mdDoc "GVfs, a userspace virtual filesystem");

     

       33
       33
        
       

     

       34
       34
        
             # gvfs can be built with multiple configurations

     

       35
       35
        
             package = mkOption {

+1 -1

nixos/modules/services/desktops/malcontent.nix

···

       12
       12
        
       

     

       13
       13
        
           services.malcontent = {

     

       14
       14
        
       

     

       15
       15
       -
             enable = mkEnableOption "Malcontent, parental control support for applications";

     

       15
       15
       +
             enable = mkEnableOption (lib.mdDoc "Malcontent, parental control support for applications");

     

       16
       16
        
       

     

       17
       17
        
           };

     

       18
       18

+1 -1

nixos/modules/services/desktops/neard.nix

···

       7
       7
        
         ###### interface

     

       8
       8
        
         options = {

     

       9
       9
        
           services.neard = {

     

       10
       10
       -
             enable = mkEnableOption "neard, NFC daemon";

     

       10
       10
       +
             enable = mkEnableOption (lib.mdDoc "neard, NFC daemon");

     

       11
       11
        
           };

     

       12
       12
        
         };

     

       13
       13

+5 -5

nixos/modules/services/desktops/pipewire/pipewire.nix

···

       50
       50
        
         ###### interface

     

       51
       51
        
         options = {

     

       52
       52
        
           services.pipewire = {

     

       53
       53
       -
             enable = mkEnableOption "pipewire service";

     

       53
       53
       +
             enable = mkEnableOption (lib.mdDoc "pipewire service");

     

       54
       54
        
       

     

       55
       55
        
             package = mkOption {

     

       56
       56
        
               type = types.package;

     
···

       127
       127
        
             };

     

       128
       128
        
       

     

       129
       129
        
             alsa = {

     

       130
       130
       -
               enable = mkEnableOption "ALSA support";

     

       131
       131
       -
               support32Bit = mkEnableOption "32-bit ALSA support on 64-bit systems";

     

       130
       130
       +
               enable = mkEnableOption (lib.mdDoc "ALSA support");

     

       131
       131
       +
               support32Bit = mkEnableOption (lib.mdDoc "32-bit ALSA support on 64-bit systems");

     

       132
       132
        
             };

     

       133
       133
        
       

     

       134
       134
        
             jack = {

     

       135
       135
       -
               enable = mkEnableOption "JACK audio emulation";

     

       135
       135
       +
               enable = mkEnableOption (lib.mdDoc "JACK audio emulation");

     

       136
       136
        
             };

     

       137
       137
        
       

     

       138
       138
        
             pulse = {

     

       139
       139
       -
               enable = mkEnableOption "PulseAudio server emulation";

     

       139
       139
       +
               enable = mkEnableOption (lib.mdDoc "PulseAudio server emulation");

     

       140
       140
        
             };

     

       141
       141
        
       

     

       142
       142
        
             systemWide = lib.mkOption {

+1 -1

nixos/modules/services/desktops/system-config-printer.nix

···

       10
       10
        
       

     

       11
       11
        
           services.system-config-printer = {

     

       12
       12
        
       

     

       13
       13
       -
             enable = mkEnableOption "system-config-printer, a service for CUPS administration used by printing interfaces";

     

       13
       13
       +
             enable = mkEnableOption (lib.mdDoc "system-config-printer, a service for CUPS administration used by printing interfaces");

     

       14
       14
        
       

     

       15
       15
        
           };

     

       16
       16

+1 -1

nixos/modules/services/desktops/tumbler.nix

···

       28
       28
        
       

     

       29
       29
        
           services.tumbler = {

     

       30
       30
        
       

     

       31
       31
       -
             enable = mkEnableOption "Tumbler, A D-Bus thumbnailer service";

     

       31
       31
       +
             enable = mkEnableOption (lib.mdDoc "Tumbler, A D-Bus thumbnailer service");

     

       32
       32
        
       

     

       33
       33
        
           };

     

       34
       34

+1 -1

nixos/modules/services/desktops/zeitgeist.nix

···

       14
       14
        
       

     

       15
       15
        
         options = {

     

       16
       16
        
           services.zeitgeist = {

     

       17
       17
       -
             enable = mkEnableOption "zeitgeist";

     

       17
       17
       +
             enable = mkEnableOption (lib.mdDoc "zeitgeist");

     

       18
       18
        
           };

     

       19
       19
        
         };

     

       20
       20

+1 -1

nixos/modules/services/development/blackfire.nix

···

       16
       16
        
       

     

       17
       17
        
         options = {

     

       18
       18
        
           services.blackfire-agent = {

     

       19
       19
       -
             enable = lib.mkEnableOption "Blackfire profiler agent";

     

       19
       19
       +
             enable = lib.mkEnableOption (lib.mdDoc "Blackfire profiler agent");

     

       20
       20
        
             settings = lib.mkOption {

     

       21
       21
        
               description = lib.mdDoc ''

     

       22
       22
        
                 See https://blackfire.io/docs/up-and-running/configuration/agent

+2 -2

nixos/modules/services/development/distccd.nix

···

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.distccd = {

     

       11
       11
       -
             enable = mkEnableOption "distccd";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "distccd");

     

       12
       12
        
       

     

       13
       13
        
             allowedClients = mkOption {

     

       14
       14
        
               type = types.listOf types.str;

     
···

       84
       84
        
             };

     

       85
       85
        
       

     

       86
       86
        
             stats = {

     

       87
       87
       -
               enable = mkEnableOption "statistics reporting via HTTP server";

     

       87
       87
       +
               enable = mkEnableOption (lib.mdDoc "statistics reporting via HTTP server");

     

       88
       88
        
               port = mkOption {

     

       89
       89
        
                 type = types.port;

     

       90
       90
        
                 default = 3633;

+3 -3

nixos/modules/services/development/hoogle.nix

···

       14
       14
        
       in {

     

       15
       15
        
       

     

       16
       16
        
         options.services.hoogle = {

     

       17
       17
       -
           enable = mkEnableOption "Haskell documentation server";

     

       17
       17
       +
           enable = mkEnableOption (lib.mdDoc "Haskell documentation server");

     

       18
       18
        
       

     

       19
       19
        
           port = mkOption {

     

       20
       20
        
             type = types.port;

     
···

       29
       29
        
             default = hp: [];

     

       30
       30
        
             defaultText = literalExpression "hp: []";

     

       31
       31
        
             example = literalExpression "hp: with hp; [ text lens ]";

     

       32
       32
       -
             description = ''

     

       32
       32
       +
             description = lib.mdDoc ''

     

       33
       33
        
               The Haskell packages to generate documentation for.

     

       34
       34
        
       

     

       35
       35
        
               The option value is a function that takes the package set specified in

     

       36
       36
       -
               the <varname>haskellPackages</varname> option as its sole parameter and

     

       36
       36
       +
               the {var}`haskellPackages` option as its sole parameter and

     

       37
       37
        
               returns a list of packages.

     

       38
       38
        
             '';

     

       39
       39
        
           };

+1 -1

nixos/modules/services/development/jupyter/default.nix

···

       24
       24
        
         meta.maintainers = with maintainers; [ aborsu ];

     

       25
       25
        
       

     

       26
       26
        
         options.services.jupyter = {

     

       27
       27
       -
           enable = mkEnableOption "Jupyter development server";

     

       27
       27
       +
           enable = mkEnableOption (lib.mdDoc "Jupyter development server");

     

       28
       28
        
       

     

       29
       29
        
           ip = mkOption {

     

       30
       30
        
             type = types.str;

+1 -1

nixos/modules/services/development/jupyterhub/default.nix

···

       30
       30
        
         meta.maintainers = with maintainers; [ costrouc ];

     

       31
       31
        
       

     

       32
       32
        
         options.services.jupyterhub = {

     

       33
       33
       -
           enable = mkEnableOption "Jupyterhub development server";

     

       33
       33
       +
           enable = mkEnableOption (lib.mdDoc "Jupyterhub development server");

     

       34
       34
        
       

     

       35
       35
        
           authentication = mkOption {

     

       36
       36
        
             type = types.str;

+1 -1

nixos/modules/services/development/rstudio-server/default.nix

···

       21
       21
        
         meta.maintainers = with maintainers; [ jbedo cfhammill ];

     

       22
       22
        
       

     

       23
       23
        
         options.services.rstudio-server = {

     

       24
       24
       -
           enable = mkEnableOption "RStudio server";

     

       24
       24
       +
           enable = mkEnableOption (lib.mdDoc "RStudio server");

     

       25
       25
        
       

     

       26
       26
        
           serverWorkingDir = mkOption {

     

       27
       27
        
             type = types.str;

+1 -1

nixos/modules/services/development/zammad.nix

···

       28
       28
        
       

     

       29
       29
        
         options = {

     

       30
       30
        
           services.zammad = {

     

       31
       31
       -
             enable = mkEnableOption "Zammad, a web-based, open source user support/ticketing solution.";

     

       31
       31
       +
             enable = mkEnableOption (lib.mdDoc "Zammad, a web-based, open source user support/ticketing solution.");

     

       32
       32
        
       

     

       33
       33
        
             package = mkOption {

     

       34
       34
        
               type = types.package;

+1 -1

nixos/modules/services/display-managers/greetd.nix

···

       8
       8
        
       in

     

       9
       9
        
       {

     

       10
       10
        
         options.services.greetd = {

     

       11
       11
       -
           enable = mkEnableOption "greetd";

     

       11
       11
       +
           enable = mkEnableOption (lib.mdDoc "greetd");

     

       12
       12
        
       

     

       13
       13
        
           package = mkOption {

     

       14
       14
        
             type = types.package;

+6 -6

nixos/modules/services/editors/emacs.nix

···

       41
       41
        
           enable = mkOption {

     

       42
       42
        
             type = types.bool;

     

       43
       43
        
             default = false;

     

       44
       44
       -
             description = ''

     

       45
       45
       -
               Whether to enable a user service for the Emacs daemon. Use <literal>emacsclient</literal> to connect to the

     

       46
       46
       -
               daemon. If <literal>true</literal>, <varname>services.emacs.install</varname> is

     

       47
       47
       -
               considered <literal>true</literal>, whatever its value.

     

       44
       44
       +
             description = lib.mdDoc ''

     

       45
       45
       +
               Whether to enable a user service for the Emacs daemon. Use `emacsclient` to connect to the

     

       46
       46
       +
               daemon. If `true`, {var}`services.emacs.install` is

     

       47
       47
       +
               considered `true`, whatever its value.

     

       48
       48
        
             '';

     

       49
       49
        
           };

     

       50
       50
        
       

     

       51
       51
        
           install = mkOption {

     

       52
       52
        
             type = types.bool;

     

       53
       53
        
             default = false;

     

       54
       54
       -
             description = ''

     

       54
       54
       +
             description = lib.mdDoc ''

     

       55
       55
        
               Whether to install a user service for the Emacs daemon. Once

     

       56
       56
        
               the service is started, use emacsclient to connect to the

     

       57
       57
        
               daemon.

     

       58
       58
        
       

     

       59
       59
        
               The service must be manually started for each user with

     

       60
       60
        
               "systemctl --user start emacs" or globally through

     

       61
       61
       -
               <varname>services.emacs.enable</varname>.

     

       61
       61
       +
               {var}`services.emacs.enable`.

     

       62
       62
        
             '';

     

       63
       63
        
           };

     

       64
       64

+2 -2

nixos/modules/services/editors/haste.nix

···

       10
       10
        
       in

     

       11
       11
        
       {

     

       12
       12
        
         options.services.haste-server = {

     

       13
       13
       -
           enable = mkEnableOption "haste-server";

     

       14
       14
       -
           openFirewall = mkEnableOption "firewall passthrough for haste-server";

     

       13
       13
       +
           enable = mkEnableOption (lib.mdDoc "haste-server");

     

       14
       14
       +
           openFirewall = mkEnableOption (lib.mdDoc "firewall passthrough for haste-server");

     

       15
       15
        
       

     

       16
       16
        
           settings = mkOption {

     

       17
       17
        
             description = lib.mdDoc ''

+1 -1

nixos/modules/services/editors/infinoted.nix

···

       6
       6
        
         cfg = config.services.infinoted;

     

       7
       7
        
       in {

     

       8
       8
        
         options.services.infinoted = {

     

       9
       9
       -
           enable = mkEnableOption "infinoted";

     

       9
       9
       +
           enable = mkEnableOption (lib.mdDoc "infinoted");

     

       10
       10
        
       

     

       11
       11
        
           package = mkOption {

     

       12
       12
        
             type = types.package;

+1 -1

nixos/modules/services/finance/odoo.nix

···

       9
       9
        
       {

     

       10
       10
        
         options = {

     

       11
       11
        
           services.odoo = {

     

       12
       12
       -
             enable = mkEnableOption "odoo";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "odoo");

     

       13
       13
        
       

     

       14
       14
        
             package = mkOption {

     

       15
       15
        
               type = types.package;

+1 -1

nixos/modules/services/games/asf.nix

···

       44
       44
        
             type = types.submodule {

     

       45
       45
        
               options = {

     

       46
       46
        
                 enable = mkEnableOption

     

       47
       47
       -
                   "Wheter to start the web-ui. This is the preferred way of configuring things such as the steam guard token";

     

       47
       47
       +
                   (lib.mdDoc "Wheter to start the web-ui. This is the preferred way of configuring things such as the steam guard token");

     

       48
       48
        
       

     

       49
       49
        
                 package = mkOption {

     

       50
       50
        
                   type = types.package;

+1 -1

nixos/modules/services/games/factorio.nix

···

       44
       44
        
       {

     

       45
       45
        
         options = {

     

       46
       46
        
           services.factorio = {

     

       47
       47
       -
             enable = mkEnableOption name;

     

       47
       47
       +
             enable = mkEnableOption (lib.mdDoc name);

     

       48
       48
        
             port = mkOption {

     

       49
       49
        
               type = types.int;

     

       50
       50
        
               default = 34197;

+6 -6

nixos/modules/services/games/freeciv.nix

···

       25
       25
        
       {

     

       26
       26
        
         options = {

     

       27
       27
        
           services.freeciv = {

     

       28
       28
       -
             enable = mkEnableOption ''freeciv'';

     

       28
       28
       +
             enable = mkEnableOption (lib.mdDoc ''freeciv'');

     

       29
       29
        
             settings = mkOption {

     

       30
       30
        
               description = lib.mdDoc ''

     

       31
       31
        
                 Parameters of freeciv-server.

     
···

       38
       38
        
                   default = "none";

     

       39
       39
        
                   description = lib.mdDoc "Announce game in LAN using given protocol.";

     

       40
       40
        
                 };

     

       41
       41
       -
                 options.auth = mkEnableOption "server authentication";

     

       41
       41
       +
                 options.auth = mkEnableOption (lib.mdDoc "server authentication");

     

       42
       42
        
                 options.Database = mkOption {

     

       43
       43
        
                   type = types.nullOr types.str;

     

       44
       44
        
                   apply = pkgs.writeText "auth.conf";

     
···

       54
       54
        
                   default = 0;

     

       55
       55
        
                   description = lib.mdDoc "Set debug log level.";

     

       56
       56
        
                 };

     

       57
       57
       -
                 options.exit-on-end = mkEnableOption "exit instead of restarting when a game ends.";

     

       58
       58
       -
                 options.Guests = mkEnableOption "guests to login if auth is enabled";

     

       59
       59
       -
                 options.Newusers = mkEnableOption "new users to login if auth is enabled";

     

       57
       57
       +
                 options.exit-on-end = mkEnableOption (lib.mdDoc "exit instead of restarting when a game ends.");

     

       58
       58
       +
                 options.Guests = mkEnableOption (lib.mdDoc "guests to login if auth is enabled");

     

       59
       59
       +
                 options.Newusers = mkEnableOption (lib.mdDoc "new users to login if auth is enabled");

     

       60
       60
        
                 options.port = mkOption {

     

       61
       61
        
                   type = types.port;

     

       62
       62
        
                   default = 5556;

     
···

       86
       86
        
                 };

     

       87
       87
        
               };

     

       88
       88
        
             };

     

       89
       89
       -
             openFirewall = mkEnableOption "opening the firewall for the port listening for clients";

     

       89
       89
       +
             openFirewall = mkEnableOption (lib.mdDoc "opening the firewall for the port listening for clients");

     

       90
       90
        
           };

     

       91
       91
        
         };

     

       92
       92
        
         config = mkIf cfg.enable {

+1 -1

nixos/modules/services/games/openarena.nix

···

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.openarena = {

     

       11
       11
       -
             enable = mkEnableOption "OpenArena";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "OpenArena");

     

       12
       12
        
       

     

       13
       13
        
             openPorts = mkOption {

     

       14
       14
        
               type = types.bool;

+1 -1

nixos/modules/services/games/quake3-server.nix

···

       37
       37
        
       in {

     

       38
       38
        
         options = {

     

       39
       39
        
           services.quake3-server = {

     

       40
       40
       -
             enable = mkEnableOption "Quake 3 dedicated server";

     

       40
       40
       +
             enable = mkEnableOption (lib.mdDoc "Quake 3 dedicated server");

     

       41
       41
        
       

     

       42
       42
        
             port = mkOption {

     

       43
       43
        
               type = types.port;

+1 -1

nixos/modules/services/games/teeworlds.nix

···

       20
       20
        
       {

     

       21
       21
        
         options = {

     

       22
       22
        
           services.teeworlds = {

     

       23
       23
       -
             enable = mkEnableOption "Teeworlds Server";

     

       23
       23
       +
             enable = mkEnableOption (lib.mdDoc "Teeworlds Server");

     

       24
       24
        
       

     

       25
       25
        
             openPorts = mkOption {

     

       26
       26
        
               type = types.bool;

+1 -1

nixos/modules/services/hardware/acpid.nix

···

       48
       48
        
       

     

       49
       49
        
           services.acpid = {

     

       50
       50
        
       

     

       51
       51
       -
             enable = mkEnableOption "the ACPI daemon";

     

       51
       51
       +
             enable = mkEnableOption (lib.mdDoc "the ACPI daemon");

     

       52
       52
        
       

     

       53
       53
        
             logEvents = mkOption {

     

       54
       54
        
               type = types.bool;

+4 -4

nixos/modules/services/hardware/actkbd.nix

···

       57
       57
        
             enable = mkOption {

     

       58
       58
        
               type = types.bool;

     

       59
       59
        
               default = false;

     

       60
       60
       -
               description = ''

     

       61
       61
       -
                 Whether to enable the <command>actkbd</command> key mapping daemon.

     

       60
       60
       +
               description = lib.mdDoc ''

     

       61
       61
       +
                 Whether to enable the {command}`actkbd` key mapping daemon.

     

       62
       62
        
       

     

       63
       63
       -
                 Turning this on will start an <command>actkbd</command>

     

       63
       63
       +
                 Turning this on will start an {command}`actkbd`

     

       64
       64
        
                 instance for every evdev input that has at least one key

     

       65
       65
        
                 (which is okay even for systems with tiny memory footprint,

     

       66
       66
       -
                 since actkbd normally uses &lt;100 bytes of memory per

     

       66
       66
       +
                 since actkbd normally uses \<100 bytes of memory per

     

       67
       67
        
                 instance).

     

       68
       68
        
       

     

       69
       69
        
                 This allows binding keys globally without the need for e.g.

+1 -1

nixos/modules/services/hardware/argonone.nix

···

       5
       5
        
       in

     

       6
       6
        
       {

     

       7
       7
        
         options.services.hardware.argonone = {

     

       8
       8
       -
           enable = lib.mkEnableOption "the driver for Argon One Raspberry Pi case fan and power button";

     

       8
       8
       +
           enable = lib.mkEnableOption (lib.mdDoc "the driver for Argon One Raspberry Pi case fan and power button");

     

       9
       9
        
           package = lib.mkOption {

     

       10
       10
        
             type = lib.types.package;

     

       11
       11
        
             default = pkgs.argononed;

+1 -1

nixos/modules/services/hardware/auto-cpufreq.nix

···

       5
       5
        
       in {

     

       6
       6
        
         options = {

     

       7
       7
        
           services.auto-cpufreq = {

     

       8
       8
       -
             enable = mkEnableOption "auto-cpufreq daemon";

     

       8
       8
       +
             enable = mkEnableOption (lib.mdDoc "auto-cpufreq daemon");

     

       9
       9
        
           };

     

       10
       10
        
         };

     

       11
       11

+2 -2

nixos/modules/services/hardware/bluetooth.nix

···

       36
       36
        
         options = {

     

       37
       37
        
       

     

       38
       38
        
           hardware.bluetooth = {

     

       39
       39
       -
             enable = mkEnableOption "support for Bluetooth";

     

       39
       39
       +
             enable = mkEnableOption (lib.mdDoc "support for Bluetooth");

     

       40
       40
        
       

     

       41
       41
       -
             hsphfpd.enable = mkEnableOption "support for hsphfpd[-prototype] implementation";

     

       41
       41
       +
             hsphfpd.enable = mkEnableOption (lib.mdDoc "support for hsphfpd[-prototype] implementation");

     

       42
       42
        
       

     

       43
       43
        
             powerOnBoot = mkOption {

     

       44
       44
        
               type = types.bool;

+1 -1

nixos/modules/services/hardware/ddccontrol.nix

···

       13
       13
        
       

     

       14
       14
        
         options = {

     

       15
       15
        
           services.ddccontrol = {

     

       16
       16
       -
             enable = lib.mkEnableOption "ddccontrol for controlling displays";

     

       16
       16
       +
             enable = lib.mkEnableOption (lib.mdDoc "ddccontrol for controlling displays");

     

       17
       17
        
           };

     

       18
       18
        
         };

     

       19
       19

+1 -1

nixos/modules/services/hardware/fancontrol.nix

···

       9
       9
        
       in

     

       10
       10
        
       {

     

       11
       11
        
         options.hardware.fancontrol = {

     

       12
       12
       -
           enable = mkEnableOption "software fan control (requires fancontrol.config)";

     

       12
       12
       +
           enable = mkEnableOption (lib.mdDoc "software fan control (requires fancontrol.config)");

     

       13
       13
        
       

     

       14
       14
        
           config = mkOption {

     

       15
       15
        
             type = types.lines;

+1 -1

nixos/modules/services/hardware/irqbalance.nix

···

       9
       9
        
       

     

       10
       10
        
       in

     

       11
       11
        
       {

     

       12
       12
       -
         options.services.irqbalance.enable = mkEnableOption "irqbalance daemon";

     

       12
       12
       +
         options.services.irqbalance.enable = mkEnableOption (lib.mdDoc "irqbalance daemon");

     

       13
       13
        
       

     

       14
       14
        
         config = mkIf cfg.enable {

     

       15
       15

+1 -1

nixos/modules/services/hardware/joycond.nix

···

       9
       9
        
       

     

       10
       10
        
       {

     

       11
       11
        
         options.services.joycond = {

     

       12
       12
       -
           enable = mkEnableOption "support for Nintendo Pro Controllers and Joycons";

     

       12
       12
       +
           enable = mkEnableOption (lib.mdDoc "support for Nintendo Pro Controllers and Joycons");

     

       13
       13
        
       

     

       14
       14
        
           package = mkOption {

     

       15
       15
        
             type = types.package;

+1 -1

nixos/modules/services/hardware/kanata.nix

···

       176
       176
        
       in

     

       177
       177
        
       {

     

       178
       178
        
         options.services.kanata = {

     

       179
       179
       -
           enable = mkEnableOption "kanata";

     

       179
       179
       +
           enable = mkEnableOption (lib.mdDoc "kanata");

     

       180
       180
        
           package = mkOption {

     

       181
       181
        
             type = types.package;

     

       182
       182
        
             default = pkgs.kanata;

+1 -1

nixos/modules/services/hardware/lirc.nix

···

       11
       11
        
         options = {

     

       12
       12
        
           services.lirc = {

     

       13
       13
        
       

     

       14
       14
       -
             enable = mkEnableOption "LIRC daemon";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "LIRC daemon");

     

       15
       15
        
       

     

       16
       16
        
             options = mkOption {

     

       17
       17
        
               type = types.lines;

+1 -1

nixos/modules/services/hardware/pcscd.nix

···

       16
       16
        
         ###### interface

     

       17
       17
        
       

     

       18
       18
        
         options.services.pcscd = {

     

       19
       19
       -
           enable = mkEnableOption "PCSC-Lite daemon";

     

       19
       19
       +
           enable = mkEnableOption (lib.mdDoc "PCSC-Lite daemon");

     

       20
       20
        
       

     

       21
       21
        
           plugins = mkOption {

     

       22
       22
        
             type = types.listOf types.package;

+2 -2

nixos/modules/services/hardware/rasdaemon.nix

···

       10
       10
        
       {

     

       11
       11
        
         options.hardware.rasdaemon = {

     

       12
       12
        
       

     

       13
       13
       -
           enable = mkEnableOption "RAS logging daemon";

     

       13
       13
       +
           enable = mkEnableOption (lib.mdDoc "RAS logging daemon");

     

       14
       14
        
       

     

       15
       15
        
           record = mkOption {

     

       16
       16
        
             type = types.bool;

     
···

       76
       76
        
             example = [ "i7core_edac" ];

     

       77
       77
        
           };

     

       78
       78
        
       

     

       79
       79
       -
           testing = mkEnableOption "error injection infrastructure";

     

       79
       79
       +
           testing = mkEnableOption (lib.mdDoc "error injection infrastructure");

     

       80
       80
        
         };

     

       81
       81
        
       

     

       82
       82
        
         config = mkIf cfg.enable {

+1 -1

nixos/modules/services/hardware/ratbagd.nix

···

       10
       10
        
       

     

       11
       11
        
         options = {

     

       12
       12
        
           services.ratbagd = {

     

       13
       13
       -
             enable = mkEnableOption "ratbagd for configuring gaming mice";

     

       13
       13
       +
             enable = mkEnableOption (lib.mdDoc "ratbagd for configuring gaming mice");

     

       14
       14
        
           };

     

       15
       15
        
         };

     

       16
       16

+1 -1

nixos/modules/services/hardware/sane_extra_backends/brscan5.nix

···

       68
       68
        
         options = {

     

       69
       69
        
       

     

       70
       70
        
           hardware.sane.brscan5.enable =

     

       71
       71
       -
             mkEnableOption "the Brother brscan5 sane backend";

     

       71
       71
       +
             mkEnableOption (lib.mdDoc "the Brother brscan5 sane backend");

     

       72
       72
        
       

     

       73
       73
        
           hardware.sane.brscan5.netDevices = mkOption {

     

       74
       74
        
             default = {};

+1 -1

nixos/modules/services/hardware/spacenavd.nix

···

       8
       8
        
       

     

       9
       9
        
         options = {

     

       10
       10
        
           hardware.spacenavd = {

     

       11
       11
       -
             enable = mkEnableOption "spacenavd to support 3DConnexion devices";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "spacenavd to support 3DConnexion devices");

     

       12
       12
        
           };

     

       13
       13
        
         };

     

       14
       14

+1 -1

nixos/modules/services/hardware/thermald.nix

···

       9
       9
        
         ###### interface

     

       10
       10
        
         options = {

     

       11
       11
        
           services.thermald = {

     

       12
       12
       -
             enable = mkEnableOption "thermald, the temperature management daemon";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "thermald, the temperature management daemon");

     

       13
       13
        
       

     

       14
       14
        
             debug = mkOption {

     

       15
       15
        
               type = types.bool;

+1 -1

nixos/modules/services/hardware/throttled.nix

···

       7
       7
        
       in {

     

       8
       8
        
         options = {

     

       9
       9
        
           services.throttled = {

     

       10
       10
       -
             enable = mkEnableOption "fix for Intel CPU throttling";

     

       10
       10
       +
             enable = mkEnableOption (lib.mdDoc "fix for Intel CPU throttling");

     

       11
       11
        
       

     

       12
       12
        
             extraConfig = mkOption {

     

       13
       13
        
               type = types.str;

+2 -2

nixos/modules/services/hardware/udev.nix

···

       222
       222
        
             path = mkOption {

     

       223
       223
        
               type = types.listOf types.path;

     

       224
       224
        
               default = [];

     

       225
       225
       -
               description = ''

     

       226
       226
       -
                 Packages added to the <envar>PATH</envar> environment variable when

     

       225
       225
       +
               description = lib.mdDoc ''

     

       226
       226
       +
                 Packages added to the {env}`PATH` environment variable when

     

       227
       227
        
                 executing programs from Udev rules.

     

       228
       228
        
               '';

     

       229
       229
        
             };

+1 -1

nixos/modules/services/hardware/udisks2.nix

···

       19
       19
        
       

     

       20
       20
        
           services.udisks2 = {

     

       21
       21
        
       

     

       22
       22
       -
             enable = mkEnableOption "udisks2, a DBus service that allows applications to query and manipulate storage devices.";

     

       22
       22
       +
             enable = mkEnableOption (lib.mdDoc "udisks2, a DBus service that allows applications to query and manipulate storage devices.");

     

       23
       23
        
       

     

       24
       24
        
             settings = mkOption rec {

     

       25
       25
        
               type = types.attrsOf settingsFormat.type;

+2 -2

nixos/modules/services/hardware/undervolt.nix

···

       33
       33
        
       in

     

       34
       34
        
       {

     

       35
       35
        
         options.services.undervolt = {

     

       36
       36
       -
           enable = mkEnableOption ''

     

       36
       36
       +
           enable = mkEnableOption (lib.mdDoc ''

     

       37
       37
        
              Undervolting service for Intel CPUs.

     

       38
       38
        
       

     

       39
       39
        
              Warning: This service is not endorsed by Intel and may permanently damage your hardware. Use at your own risk!

     

       40
       40
       -
           '';

     

       40
       40
       +
           '');

     

       41
       41
        
       

     

       42
       42
        
           verbose = mkOption {

     

       43
       43
        
             type = types.bool;

+1 -1

nixos/modules/services/hardware/usbrelayd.nix

···

       5
       5
        
       in

     

       6
       6
        
       {

     

       7
       7
        
         options.services.usbrelayd = with types; {

     

       8
       8
       -
           enable = mkEnableOption "USB Relay MQTT daemon";

     

       8
       8
       +
           enable = mkEnableOption (lib.mdDoc "USB Relay MQTT daemon");

     

       9
       9
        
       

     

       10
       10
        
           broker = mkOption {

     

       11
       11
        
             type = str;

+2 -2

nixos/modules/services/hardware/vdr.nix

···

       12
       12
        
         options = {

     

       13
       13
        
       

     

       14
       14
        
           services.vdr = {

     

       15
       15
       -
             enable = mkEnableOption "VDR. Please put config into ${libDir}";

     

       15
       15
       +
             enable = mkEnableOption (lib.mdDoc "VDR. Please put config into ${libDir}");

     

       16
       16
        
       

     

       17
       17
        
             package = mkOption {

     

       18
       18
        
               type = types.package;

     
···

       34
       34
        
               description = lib.mdDoc "Additional command line arguments to pass to VDR.";

     

       35
       35
        
             };

     

       36
       36
        
       

     

       37
       37
       -
             enableLirc = mkEnableOption "LIRC";

     

       37
       37
       +
             enableLirc = mkEnableOption (lib.mdDoc "LIRC");

     

       38
       38
        
           };

     

       39
       39
        
         };

     

       40
       40

+1 -1

nixos/modules/services/home-automation/home-assistant.nix

···

       77
       77
        
         options.services.home-assistant = {

     

       78
       78
        
           # Running home-assistant on NixOS is considered an installation method that is unsupported by the upstream project.

     

       79
       79
        
           # https://github.com/home-assistant/architecture/blob/master/adr/0012-define-supported-installation-method.md#decision

     

       80
       80
       -
           enable = mkEnableOption "Home Assistant. Please note that this installation method is unsupported upstream";

     

       80
       80
       +
           enable = mkEnableOption (lib.mdDoc "Home Assistant. Please note that this installation method is unsupported upstream");

     

       81
       81
        
       

     

       82
       82
        
           configDir = mkOption {

     

       83
       83
        
             default = "/var/lib/hass";

+1 -1

nixos/modules/services/home-automation/zigbee2mqtt.nix

···

       18
       18
        
         ];

     

       19
       19
        
       

     

       20
       20
        
         options.services.zigbee2mqtt = {

     

       21
       21
       -
           enable = mkEnableOption "enable zigbee2mqtt service";

     

       21
       21
       +
           enable = mkEnableOption (lib.mdDoc "enable zigbee2mqtt service");

     

       22
       22
        
       

     

       23
       23
        
           package = mkOption {

     

       24
       24
        
             description = lib.mdDoc "Zigbee2mqtt package to use";

+2 -2

nixos/modules/services/logging/awstats.nix

···

       69
       69
        
             };

     

       70
       70
        
       

     

       71
       71
        
             webService = {

     

       72
       72
       -
               enable = mkEnableOption "awstats web service";

     

       72
       72
       +
               enable = mkEnableOption (lib.mdDoc "awstats web service");

     

       73
       73
        
       

     

       74
       74
        
               hostname = mkOption {

     

       75
       75
        
                 type = types.str;

     
···

       95
       95
        
         ];

     

       96
       96
        
       

     

       97
       97
        
         options.services.awstats = {

     

       98
       98
       -
           enable = mkEnableOption "awstats";

     

       98
       98
       +
           enable = mkEnableOption (lib.mdDoc "awstats");

     

       99
       99
        
       

     

       100
       100
        
           dataDir = mkOption {

     

       101
       101
        
             type = types.path;

+1 -1

nixos/modules/services/logging/filebeat.nix

···

       18
       18
        
       

     

       19
       19
        
           services.filebeat = {

     

       20
       20
        
       

     

       21
       21
       -
             enable = mkEnableOption "filebeat";

     

       21
       21
       +
             enable = mkEnableOption (lib.mdDoc "filebeat");

     

       22
       22
        
       

     

       23
       23
        
             package = mkOption {

     

       24
       24
        
               type = types.package;

+1 -1

nixos/modules/services/logging/graylog.nix

···

       33
       33
        
       

     

       34
       34
        
           services.graylog = {

     

       35
       35
        
       

     

       36
       36
       -
             enable = mkEnableOption "Graylog";

     

       36
       36
       +
             enable = mkEnableOption (lib.mdDoc "Graylog");

     

       37
       37
        
       

     

       38
       38
        
             package = mkOption {

     

       39
       39
        
               type = types.package;

+1 -1

nixos/modules/services/logging/heartbeat.nix

···

       18
       18
        
       

     

       19
       19
        
           services.heartbeat = {

     

       20
       20
        
       

     

       21
       21
       -
             enable = mkEnableOption "heartbeat";

     

       21
       21
       +
             enable = mkEnableOption (lib.mdDoc "heartbeat");

     

       22
       22
        
       

     

       23
       23
        
             package = mkOption {

     

       24
       24
        
               type = types.package;

+1 -1

nixos/modules/services/logging/journalbeat.nix

···

       18
       18
        
       

     

       19
       19
        
           services.journalbeat = {

     

       20
       20
        
       

     

       21
       21
       -
             enable = mkEnableOption "journalbeat";

     

       21
       21
       +
             enable = mkEnableOption (lib.mdDoc "journalbeat");

     

       22
       22
        
       

     

       23
       23
        
             package = mkOption {

     

       24
       24
        
               type = types.package;

+2 -2

nixos/modules/services/logging/logrotate.nix

···

       205
       205
        
       

     

       206
       206
        
         options = {

     

       207
       207
        
           services.logrotate = {

     

       208
       208
       -
             enable = mkEnableOption "the logrotate systemd service" // {

     

       208
       208
       +
             enable = mkEnableOption (lib.mdDoc "the logrotate systemd service") // {

     

       209
       209
        
               default = foldr (n: a: a || n.enable) false (attrValues cfg.settings);

     

       210
       210
        
               defaultText = literalExpression "cfg.settings != {}";

     

       211
       211
        
             };

     
···

       222
       222
        
                 freeformType = with types; attrsOf (nullOr (oneOf [ int bool str ]));

     

       223
       223
        
       

     

       224
       224
        
                 options = {

     

       225
       225
       -
                   enable = mkEnableOption "setting individual kill switch" // {

     

       225
       225
       +
                   enable = mkEnableOption (lib.mdDoc "setting individual kill switch") // {

     

       226
       226
        
                     default = true;

     

       227
       227
        
                   };

     

       228
       228

+1 -1

nixos/modules/services/logging/promtail.nix

···

       12
       12
        
         positionsFile = cfg.configuration.positions.filename;

     

       13
       13
        
       in {

     

       14
       14
        
         options.services.promtail = with types; {

     

       15
       15
       -
           enable = mkEnableOption "the Promtail ingresser";

     

       15
       15
       +
           enable = mkEnableOption (lib.mdDoc "the Promtail ingresser");

     

       16
       16
        
       

     

       17
       17
        
       

     

       18
       18
        
           configuration = mkOption {

+6 -6

nixos/modules/services/logging/rsyslogd.nix

···

       48
       48
        
             defaultConfig = mkOption {

     

       49
       49
        
               type = types.lines;

     

       50
       50
        
               default = defaultConf;

     

       51
       51
       -
               description = ''

     

       52
       52
       -
                 The default <filename>syslog.conf</filename> file configures a

     

       51
       51
       +
               description = lib.mdDoc ''

     

       52
       52
       +
                 The default {file}`syslog.conf` file configures a

     

       53
       53
        
                 fairly standard setup of log files, which can be extended by

     

       54
       54
       -
                 means of <varname>extraConfig</varname>.

     

       54
       54
       +
                 means of {var}`extraConfig`.

     

       55
       55
        
               '';

     

       56
       56
        
             };

     

       57
       57
        
       

     
···

       59
       59
        
               type = types.lines;

     

       60
       60
        
               default = "";

     

       61
       61
        
               example = "news.* -/var/log/news";

     

       62
       62
       -
               description = ''

     

       63
       63
       -
                 Additional text appended to <filename>syslog.conf</filename>,

     

       64
       64
       -
                 i.e. the contents of <varname>defaultConfig</varname>.

     

       62
       62
       +
               description = lib.mdDoc ''

     

       63
       63
       +
                 Additional text appended to {file}`syslog.conf`,

     

       64
       64
       +
                 i.e. the contents of {var}`defaultConfig`.

     

       65
       65
        
               '';

     

       66
       66
        
             };

     

       67
       67

+6 -6

nixos/modules/services/logging/syslogd.nix

···

       57
       57
        
             defaultConfig = mkOption {

     

       58
       58
        
               type = types.lines;

     

       59
       59
        
               default = defaultConf;

     

       60
       60
       -
               description = ''

     

       61
       61
       -
                 The default <filename>syslog.conf</filename> file configures a

     

       60
       60
       +
               description = lib.mdDoc ''

     

       61
       61
       +
                 The default {file}`syslog.conf` file configures a

     

       62
       62
        
                 fairly standard setup of log files, which can be extended by

     

       63
       63
       -
                 means of <varname>extraConfig</varname>.

     

       63
       63
       +
                 means of {var}`extraConfig`.

     

       64
       64
        
               '';

     

       65
       65
        
             };

     

       66
       66
        
       

     
···

       76
       76
        
               type = types.lines;

     

       77
       77
        
               default = "";

     

       78
       78
        
               example = "news.* -/var/log/news";

     

       79
       79
       -
               description = ''

     

       80
       80
       -
                 Additional text appended to <filename>syslog.conf</filename>,

     

       81
       81
       -
                 i.e. the contents of <varname>defaultConfig</varname>.

     

       79
       79
       +
               description = lib.mdDoc ''

     

       80
       80
       +
                 Additional text appended to {file}`syslog.conf`,

     

       81
       81
       +
                 i.e. the contents of {var}`defaultConfig`.

     

       82
       82
        
               '';

     

       83
       83
        
             };

     

       84
       84

+1 -1

nixos/modules/services/logging/vector.nix

···

       6
       6
        
       in

     

       7
       7
        
       {

     

       8
       8
        
         options.services.vector = {

     

       9
       9
       -
           enable = mkEnableOption "Vector";

     

       9
       9
       +
           enable = mkEnableOption (lib.mdDoc "Vector");

     

       10
       10
        
       

     

       11
       11
        
           journaldAccess = mkOption {

     

       12
       12
        
             type = types.bool;

+1 -1

nixos/modules/services/mail/davmail.nix

···

       25
       25
        
       

     

       26
       26
        
         {

     

       27
       27
        
           options.services.davmail = {

     

       28
       28
       -
             enable = mkEnableOption "davmail, an MS Exchange gateway";

     

       28
       28
       +
             enable = mkEnableOption (lib.mdDoc "davmail, an MS Exchange gateway");

     

       29
       29
        
       

     

       30
       30
        
             url = mkOption {

     

       31
       31
        
               type = types.str;

+11 -11

nixos/modules/services/mail/dovecot.nix

···

       169
       169
        
         ];

     

       170
       170
        
       

     

       171
       171
        
         options.services.dovecot2 = {

     

       172
       172
       -
           enable = mkEnableOption "the dovecot 2.x POP3/IMAP server";

     

       172
       172
       +
           enable = mkEnableOption (lib.mdDoc "the dovecot 2.x POP3/IMAP server");

     

       173
       173
        
       

     

       174
       174
       -
           enablePop3 = mkEnableOption "starting the POP3 listener (when Dovecot is enabled).";

     

       174
       174
       +
           enablePop3 = mkEnableOption (lib.mdDoc "starting the POP3 listener (when Dovecot is enabled).");

     

       175
       175
        
       

     

       176
       176
       -
           enableImap = mkEnableOption "starting the IMAP listener (when Dovecot is enabled)." // { default = true; };

     

       176
       176
       +
           enableImap = mkEnableOption (lib.mdDoc "starting the IMAP listener (when Dovecot is enabled).") // { default = true; };

     

       177
       177
        
       

     

       178
       178
       -
           enableLmtp = mkEnableOption "starting the LMTP listener (when Dovecot is enabled).";

     

       178
       178
       +
           enableLmtp = mkEnableOption (lib.mdDoc "starting the LMTP listener (when Dovecot is enabled).");

     

       179
       179
        
       

     

       180
       180
        
           protocols = mkOption {

     

       181
       181
        
             type = types.listOf types.str;

     
···

       267
       267
        
             description = lib.mdDoc "Default group to store mail for virtual users.";

     

       268
       268
        
           };

     

       269
       269
        
       

     

       270
       270
       -
           createMailUser = mkEnableOption ''automatically creating the user

     

       271
       271
       -
             given in <option>services.dovecot.user</option> and the group

     

       272
       272
       -
             given in <option>services.dovecot.group</option>.'' // { default = true; };

     

       270
       270
       +
           createMailUser = mkEnableOption (lib.mdDoc ''automatically creating the user

     

       271
       271
       +
             given in {option}`services.dovecot.user` and the group

     

       272
       272
       +
             given in {option}`services.dovecot.group`.'') // { default = true; };

     

       273
       273
        
       

     

       274
       274
        
           modules = mkOption {

     

       275
       275
        
             type = types.listOf types.package;

     
···

       300
       300
        
             description = lib.mdDoc "Path to the server's private key.";

     

       301
       301
        
           };

     

       302
       302
        
       

     

       303
       303
       -
           enablePAM = mkEnableOption "creating a own Dovecot PAM service and configure PAM user logins." // { default = true; };

     

       303
       303
       +
           enablePAM = mkEnableOption (lib.mdDoc "creating a own Dovecot PAM service and configure PAM user logins.") // { default = true; };

     

       304
       304
        
       

     

       305
       305
       -
           enableDHE = mkEnableOption "enable ssl_dh and generation of primes for the key exchange." // { default = true; };

     

       305
       305
       +
           enableDHE = mkEnableOption (lib.mdDoc "enable ssl_dh and generation of primes for the key exchange.") // { default = true; };

     

       306
       306
        
       

     

       307
       307
        
           sieveScripts = mkOption {

     

       308
       308
        
             type = types.attrsOf types.path;

     
···

       310
       310
        
             description = lib.mdDoc "Sieve scripts to be executed. Key is a sequence, e.g. 'before2', 'after' etc.";

     

       311
       311
        
           };

     

       312
       312
        
       

     

       313
       313
       -
           showPAMFailure = mkEnableOption "showing the PAM failure message on authentication error (useful for OTPW).";

     

       313
       313
       +
           showPAMFailure = mkEnableOption (lib.mdDoc "showing the PAM failure message on authentication error (useful for OTPW).");

     

       314
       314
        
       

     

       315
       315
        
           mailboxes = mkOption {

     

       316
       316
        
             type = with types; coercedTo

     
···

       326
       326
        
             description = lib.mdDoc "Configure mailboxes and auto create or subscribe them.";

     

       327
       327
        
           };

     

       328
       328
        
       

     

       329
       329
       -
           enableQuota = mkEnableOption "the dovecot quota service.";

     

       329
       329
       +
           enableQuota = mkEnableOption (lib.mdDoc "the dovecot quota service.");

     

       330
       330
        
       

     

       331
       331
        
           quotaPort = mkOption {

     

       332
       332
        
             type = types.str;

+1 -1

nixos/modules/services/mail/maddy.nix

···

       139
       139
        
         options = {

     

       140
       140
        
           services.maddy = {

     

       141
       141
        
       

     

       142
       142
       -
             enable = mkEnableOption "Maddy, a free an open source mail server";

     

       142
       142
       +
             enable = mkEnableOption (lib.mdDoc "Maddy, a free an open source mail server");

     

       143
       143
        
       

     

       144
       144
        
             user = mkOption {

     

       145
       145
        
               default = "maddy";

+1 -1

nixos/modules/services/mail/mailcatcher.nix

···

       11
       11
        
         options = {

     

       12
       12
        
       

     

       13
       13
        
           services.mailcatcher = {

     

       14
       14
       -
             enable = mkEnableOption "MailCatcher";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "MailCatcher");

     

       15
       15
        
       

     

       16
       16
        
             http.ip = mkOption {

     

       17
       17
        
               type = types.str;

+1 -1

nixos/modules/services/mail/mailhog.nix

···

       27
       27
        
         options = {

     

       28
       28
        
       

     

       29
       29
        
           services.mailhog = {

     

       30
       30
       -
             enable = mkEnableOption "MailHog";

     

       30
       30
       +
             enable = mkEnableOption (lib.mdDoc "MailHog");

     

       31
       31
        
       

     

       32
       32
        
             storage = mkOption {

     

       33
       33
        
               type = types.enum [ "maildir" "memory" ];

+3 -3

nixos/modules/services/mail/mailman.nix

···

       94
       94
        
             };

     

       95
       95
        
       

     

       96
       96
        
             ldap = {

     

       97
       97
       -
               enable = mkEnableOption "LDAP auth";

     

       97
       97
       +
               enable = mkEnableOption (lib.mdDoc "LDAP auth");

     

       98
       98
        
               serverUri = mkOption {

     

       99
       99
        
                 type = types.str;

     

       100
       100
        
                 example = "ldaps://ldap.host";

     
···

       262
       262
        
             };

     

       263
       263
        
       

     

       264
       264
        
             serve = {

     

       265
       265
       -
               enable = mkEnableOption "Automatic nginx and uwsgi setup for mailman-web";

     

       265
       265
       +
               enable = mkEnableOption (lib.mdDoc "Automatic nginx and uwsgi setup for mailman-web");

     

       266
       266
        
             };

     

       267
       267
        
       

     

       268
       268
        
             extraPythonPackages = mkOption {

     
···

       278
       278
        
             };

     

       279
       279
        
       

     

       280
       280
        
             hyperkitty = {

     

       281
       281
       -
               enable = mkEnableOption "the Hyperkitty archiver for Mailman";

     

       281
       281
       +
               enable = mkEnableOption (lib.mdDoc "the Hyperkitty archiver for Mailman");

     

       282
       282
        
       

     

       283
       283
        
               baseUrl = mkOption {

     

       284
       284
        
                 type = types.str;

+3 -3

nixos/modules/services/mail/offlineimap.nix

···

       7
       7
        
       in {

     

       8
       8
        
       

     

       9
       9
        
         options.services.offlineimap = {

     

       10
       10
       -
           enable = mkEnableOption "OfflineIMAP, a software to dispose your mailbox(es) as a local Maildir(s)";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "OfflineIMAP, a software to dispose your mailbox(es) as a local Maildir(s)");

     

       11
       11
        
       

     

       12
       12
        
           install = mkOption {

     

       13
       13
        
             type = types.bool;

     

       14
       14
        
             default = false;

     

       15
       15
       -
             description = ''

     

       15
       15
       +
             description = lib.mdDoc ''

     

       16
       16
        
               Whether to install a user service for Offlineimap. Once

     

       17
       17
        
               the service is started, emails will be fetched automatically.

     

       18
       18
        
       

     

       19
       19
        
               The service must be manually started for each user with

     

       20
       20
        
               "systemctl --user start offlineimap" or globally through

     

       21
       21
       -
               <varname>services.offlineimap.enable</varname>.

     

       21
       21
       +
               {var}`services.offlineimap.enable`.

     

       22
       22
        
             '';

     

       23
       23
        
           };

     

       24
       24

+7 -7

nixos/modules/services/mail/public-inbox.nix

···

       143
       143
        
       

     

       144
       144
        
       {

     

       145
       145
        
         options.services.public-inbox = {

     

       146
       146
       -
           enable = mkEnableOption "the public-inbox mail archiver";

     

       146
       146
       +
           enable = mkEnableOption (lib.mdDoc "the public-inbox mail archiver");

     

       147
       147
        
           package = mkOption {

     

       148
       148
        
             type = types.package;

     

       149
       149
        
             default = pkgs.public-inbox;

     
···

       218
       218
        
             }));

     

       219
       219
        
           };

     

       220
       220
        
           imap = {

     

       221
       221
       -
             enable = mkEnableOption "the public-inbox IMAP server";

     

       221
       221
       +
             enable = mkEnableOption (lib.mdDoc "the public-inbox IMAP server");

     

       222
       222
        
           } // publicInboxDaemonOptions "imap" 993;

     

       223
       223
        
           http = {

     

       224
       224
       -
             enable = mkEnableOption "the public-inbox HTTP server";

     

       224
       224
       +
             enable = mkEnableOption (lib.mdDoc "the public-inbox HTTP server");

     

       225
       225
        
             mounts = mkOption {

     

       226
       226
        
               type = with types; listOf str;

     

       227
       227
        
               default = [ "/" ];

     
···

       247
       247
        
             };

     

       248
       248
        
           };

     

       249
       249
        
           mda = {

     

       250
       250
       -
             enable = mkEnableOption "the public-inbox Mail Delivery Agent";

     

       250
       250
       +
             enable = mkEnableOption (lib.mdDoc "the public-inbox Mail Delivery Agent");

     

       251
       251
        
             args = mkOption {

     

       252
       252
        
               type = with types; listOf str;

     

       253
       253
        
               default = [];

     

       254
       254
        
               description = lib.mdDoc "Command-line arguments to pass to {manpage}`public-inbox-mda(1)`.";

     

       255
       255
        
             };

     

       256
       256
        
           };

     

       257
       257
       -
           postfix.enable = mkEnableOption "the integration into Postfix";

     

       257
       257
       +
           postfix.enable = mkEnableOption (lib.mdDoc "the integration into Postfix");

     

       258
       258
        
           nntp = {

     

       259
       259
       -
             enable = mkEnableOption "the public-inbox NNTP server";

     

       259
       259
       +
             enable = mkEnableOption (lib.mdDoc "the public-inbox NNTP server");

     

       260
       260
        
           } // publicInboxDaemonOptions "nntp" 563;

     

       261
       261
        
           spamAssassinRules = mkOption {

     

       262
       262
        
             type = with types; nullOr path;

     
···

       339
       339
        
               };

     

       340
       340
        
             };

     

       341
       341
        
           };

     

       342
       342
       -
           openFirewall = mkEnableOption "opening the firewall when using a port option";

     

       342
       342
       +
           openFirewall = mkEnableOption (lib.mdDoc "opening the firewall when using a port option");

     

       343
       343
        
         };

     

       344
       344
        
         config = mkIf cfg.enable {

     

       345
       345
        
           assertions = [

+1 -1

nixos/modules/services/mail/rspamd.nix

···

       227
       227
        
       

     

       228
       228
        
           services.rspamd = {

     

       229
       229
        
       

     

       230
       230
       -
             enable = mkEnableOption "rspamd, the Rapid spam filtering system";

     

       230
       230
       +
             enable = mkEnableOption (lib.mdDoc "rspamd, the Rapid spam filtering system");

     

       231
       231
        
       

     

       232
       232
        
             debug = mkOption {

     

       233
       233
        
               type = types.bool;

+2 -2

nixos/modules/services/mail/schleuder.nix

···

       18
       18
        
       in

     

       19
       19
        
       {

     

       20
       20
        
         options.services.schleuder = {

     

       21
       21
       -
           enable = lib.mkEnableOption "Schleuder secure remailer";

     

       22
       22
       -
           enablePostfix = lib.mkEnableOption "automatic postfix integration" // { default = true; };

     

       21
       21
       +
           enable = lib.mkEnableOption (lib.mdDoc "Schleuder secure remailer");

     

       22
       22
       +
           enablePostfix = lib.mkEnableOption (lib.mdDoc "automatic postfix integration") // { default = true; };

     

       23
       23
        
           lists = lib.mkOption {

     

       24
       24
        
             description = lib.mdDoc ''

     

       25
       25
        
               List of list addresses that should be handled by Schleuder.

+1 -1

nixos/modules/services/mail/spamassassin.nix

···

       12
       12
        
         options = {

     

       13
       13
        
       

     

       14
       14
        
           services.spamassassin = {

     

       15
       15
       -
             enable = mkEnableOption "the SpamAssassin daemon";

     

       15
       15
       +
             enable = mkEnableOption (lib.mdDoc "the SpamAssassin daemon");

     

       16
       16
        
       

     

       17
       17
        
             debug = mkOption {

     

       18
       18
        
               type = types.bool;

+1 -1

nixos/modules/services/mail/sympa.nix

···

       80
       80
        
         ###### interface

     

       81
       81
        
         options.services.sympa = with types; {

     

       82
       82
        
       

     

       83
       83
       -
           enable = mkEnableOption "Sympa mailing list manager";

     

       83
       83
       +
           enable = mkEnableOption (lib.mdDoc "Sympa mailing list manager");

     

       84
       84
        
       

     

       85
       85
        
           lang = mkOption {

     

       86
       86
        
             type = str;

+1 -1

nixos/modules/services/matrix/appservice-discord.nix

···

       14
       14
        
       in {

     

       15
       15
        
         options = {

     

       16
       16
        
           services.matrix-appservice-discord = {

     

       17
       17
       -
             enable = mkEnableOption "a bridge between Matrix and Discord";

     

       17
       17
       +
             enable = mkEnableOption (lib.mdDoc "a bridge between Matrix and Discord");

     

       18
       18
        
       

     

       19
       19
        
             settings = mkOption rec {

     

       20
       20
        
               # TODO: switch to types.config.json as prescribed by RFC42 once it's implemented

+1 -1

nixos/modules/services/matrix/appservice-irc.nix

···

       28
       28
        
         registrationFile = "/var/lib/matrix-appservice-irc/registration.yml";

     

       29
       29
        
       in {

     

       30
       30
        
         options.services.matrix-appservice-irc = with types; {

     

       31
       31
       -
           enable = mkEnableOption "the Matrix/IRC bridge";

     

       31
       31
       +
           enable = mkEnableOption (lib.mdDoc "the Matrix/IRC bridge");

     

       32
       32
        
       

     

       33
       33
        
           port = mkOption {

     

       34
       34
        
             type = port;

+1 -1

nixos/modules/services/matrix/conduit.nix

···

       11
       11
        
         {

     

       12
       12
        
           meta.maintainers = with maintainers; [ pstn piegames ];

     

       13
       13
        
           options.services.matrix-conduit = {

     

       14
       14
       -
             enable = mkEnableOption "matrix-conduit";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "matrix-conduit");

     

       15
       15
        
       

     

       16
       16
        
             extraEnvironment = mkOption {

     

       17
       17
        
               type = types.attrsOf types.str;

+1 -1

nixos/modules/services/matrix/dendrite.nix

···

       7
       7
        
       in

     

       8
       8
        
       {

     

       9
       9
        
         options.services.dendrite = {

     

       10
       10
       -
           enable = lib.mkEnableOption "matrix.org dendrite";

     

       10
       10
       +
           enable = lib.mkEnableOption (lib.mdDoc "matrix.org dendrite");

     

       11
       11
        
           httpPort = lib.mkOption {

     

       12
       12
        
             type = lib.types.nullOr lib.types.port;

     

       13
       13
        
             default = 8008;

+1 -1

nixos/modules/services/matrix/mautrix-facebook.nix

···

       17
       17
        
       in {

     

       18
       18
        
         options = {

     

       19
       19
        
           services.mautrix-facebook = {

     

       20
       20
       -
             enable = mkEnableOption "Mautrix-Facebook, a Matrix-Facebook hybrid puppeting/relaybot bridge";

     

       20
       20
       +
             enable = mkEnableOption (lib.mdDoc "Mautrix-Facebook, a Matrix-Facebook hybrid puppeting/relaybot bridge");

     

       21
       21
        
       

     

       22
       22
        
             settings = mkOption rec {

     

       23
       23
        
               apply = recursiveUpdate default;

+1 -1

nixos/modules/services/matrix/mautrix-telegram.nix

···

       13
       13
        
       in {

     

       14
       14
        
         options = {

     

       15
       15
        
           services.mautrix-telegram = {

     

       16
       16
       -
             enable = mkEnableOption "Mautrix-Telegram, a Matrix-Telegram hybrid puppeting/relaybot bridge";

     

       16
       16
       +
             enable = mkEnableOption (lib.mdDoc "Mautrix-Telegram, a Matrix-Telegram hybrid puppeting/relaybot bridge");

     

       17
       17
        
       

     

       18
       18
        
             settings = mkOption rec {

     

       19
       19
        
               apply = recursiveUpdate default;

+3 -3

nixos/modules/services/matrix/mjolnir.nix

···

       65
       65
        
       in

     

       66
       66
        
       {

     

       67
       67
        
         options.services.mjolnir = {

     

       68
       68
       -
           enable = mkEnableOption "Mjolnir, a moderation tool for Matrix";

     

       68
       68
       +
           enable = mkEnableOption (lib.mdDoc "Mjolnir, a moderation tool for Matrix");

     

       69
       69
        
       

     

       70
       70
        
           homeserverUrl = mkOption {

     

       71
       71
        
             type = types.str;

     
···

       95
       95
        
             default = { };

     

       96
       96
        
             type = types.submodule {

     

       97
       97
        
               options = {

     

       98
       98
       -
                 enable = mkEnableOption ''

     

       98
       98
       +
                 enable = mkEnableOption (lib.mdDoc ''

     

       99
       99
        
                   If true, accessToken is ignored and the username/password below will be

     

       100
       100
        
                   used instead. The access token of the bot will be stored in the dataPath.

     

       101
       101
       -
                 '';

     

       101
       101
       +
                 '');

     

       102
       102
        
       

     

       103
       103
        
                 username = mkOption {

     

       104
       104
        
                   type = types.str;

+1 -1

nixos/modules/services/matrix/synapse.nix

···

       138
       138
        
       

     

       139
       139
        
         options = {

     

       140
       140
        
           services.matrix-synapse = {

     

       141
       141
       -
             enable = mkEnableOption "matrix.org synapse";

     

       141
       141
       +
             enable = mkEnableOption (lib.mdDoc "matrix.org synapse");

     

       142
       142
        
       

     

       143
       143
        
             configFile = mkOption {

     

       144
       144
        
               type = types.path;

+1 -1

nixos/modules/services/misc/airsonic.nix

···

       9
       9
        
         options = {

     

       10
       10
        
       

     

       11
       11
        
           services.airsonic = {

     

       12
       12
       -
             enable = mkEnableOption "Airsonic, the Free and Open Source media streaming server (fork of Subsonic and Libresonic)";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "Airsonic, the Free and Open Source media streaming server (fork of Subsonic and Libresonic)");

     

       13
       13
        
       

     

       14
       14
        
             user = mkOption {

     

       15
       15
        
               type = types.str;

+1 -1

nixos/modules/services/misc/ananicy.nix

···

       11
       11
        
       {

     

       12
       12
        
         options = {

     

       13
       13
        
           services.ananicy = {

     

       14
       14
       -
             enable = mkEnableOption "Ananicy, an auto nice daemon";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "Ananicy, an auto nice daemon");

     

       15
       15
        
       

     

       16
       16
        
             package = mkOption {

     

       17
       17
        
               type = types.package;

+1 -1

nixos/modules/services/misc/ankisyncd.nix

···

       28
       28
        
       in

     

       29
       29
        
         {

     

       30
       30
        
           options.services.ankisyncd = {

     

       31
       31
       -
             enable = mkEnableOption "ankisyncd";

     

       31
       31
       +
             enable = mkEnableOption (lib.mdDoc "ankisyncd");

     

       32
       32
        
       

     

       33
       33
        
             package = mkOption {

     

       34
       34
        
               type = types.package;

+1 -1

nixos/modules/services/misc/autorandr.nix

···

       242
       242
        
         options = {

     

       243
       243
        
       

     

       244
       244
        
           services.autorandr = {

     

       245
       245
       -
             enable = mkEnableOption "handling of hotplug and sleep events by autorandr";

     

       245
       245
       +
             enable = mkEnableOption (lib.mdDoc "handling of hotplug and sleep events by autorandr");

     

       246
       246
        
       

     

       247
       247
        
             defaultTarget = mkOption {

     

       248
       248
        
               default = "default";

+1 -1

nixos/modules/services/misc/bazarr.nix

···

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.bazarr = {

     

       11
       11
       -
             enable = mkEnableOption "bazarr, a subtitle manager for Sonarr and Radarr";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "bazarr, a subtitle manager for Sonarr and Radarr");

     

       12
       12
        
       

     

       13
       13
        
             openFirewall = mkOption {

     

       14
       14
        
               type = types.bool;

+1 -1

nixos/modules/services/misc/beanstalkd.nix

···

       12
       12
        
       

     

       13
       13
        
         options = {

     

       14
       14
        
           services.beanstalkd = {

     

       15
       15
       -
             enable = mkEnableOption "the Beanstalk work queue";

     

       15
       15
       +
             enable = mkEnableOption (lib.mdDoc "the Beanstalk work queue");

     

       16
       16
        
       

     

       17
       17
        
             listen = {

     

       18
       18
        
               port = mkOption {

+1 -1

nixos/modules/services/misc/bepasty.nix

···

       13
       13
        
       in

     

       14
       14
        
       {

     

       15
       15
        
         options.services.bepasty = {

     

       16
       16
       -
           enable = mkEnableOption "Bepasty servers";

     

       16
       16
       +
           enable = mkEnableOption (lib.mdDoc "Bepasty servers");

     

       17
       17
        
       

     

       18
       18
        
           servers = mkOption {

     

       19
       19
        
             default = {};

+1 -1

nixos/modules/services/misc/calibre-server.nix

···

       23
       23
        
         options = {

     

       24
       24
        
           services.calibre-server = {

     

       25
       25
        
       

     

       26
       26
       -
             enable = mkEnableOption "calibre-server";

     

       26
       26
       +
             enable = mkEnableOption (lib.mdDoc "calibre-server");

     

       27
       27
        
       

     

       28
       28
        
             libraries = mkOption {

     

       29
       29
        
               description = lib.mdDoc ''

+1 -1

nixos/modules/services/misc/cfdyndns.nix

···

       14
       14
        
       

     

       15
       15
        
         options = {

     

       16
       16
        
           services.cfdyndns = {

     

       17
       17
       -
             enable = mkEnableOption "Cloudflare Dynamic DNS Client";

     

       17
       17
       +
             enable = mkEnableOption (lib.mdDoc "Cloudflare Dynamic DNS Client");

     

       18
       18
        
       

     

       19
       19
        
             email = mkOption {

     

       20
       20
        
               type = types.str;

+1 -1

nixos/modules/services/misc/cgminer.nix

···

       31
       31
        
       

     

       32
       32
        
           services.cgminer = {

     

       33
       33
        
       

     

       34
       34
       -
             enable = mkEnableOption "cgminer, an ASIC/FPGA/GPU miner for bitcoin and litecoin";

     

       34
       34
       +
             enable = mkEnableOption (lib.mdDoc "cgminer, an ASIC/FPGA/GPU miner for bitcoin and litecoin");

     

       35
       35
        
       

     

       36
       36
        
             package = mkOption {

     

       37
       37
        
               default = pkgs.cgminer;

+1 -1

nixos/modules/services/misc/clipcat.nix

···

       7
       7
        
       in {

     

       8
       8
        
       

     

       9
       9
        
         options.services.clipcat= {

     

       10
       10
       -
           enable = mkEnableOption "Clipcat clipboard daemon";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "Clipcat clipboard daemon");

     

       11
       11
        
       

     

       12
       12
        
           package = mkOption {

     

       13
       13
        
             type = types.package;

+1 -1

nixos/modules/services/misc/clipmenu.nix

···

       7
       7
        
       in {

     

       8
       8
        
       

     

       9
       9
        
         options.services.clipmenu = {

     

       10
       10
       -
           enable = mkEnableOption "clipmenu, the clipboard management daemon";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "clipmenu, the clipboard management daemon");

     

       11
       11
        
       

     

       12
       12
        
           package = mkOption {

     

       13
       13
        
             type = types.package;

+1 -1

nixos/modules/services/misc/confd.nix

···

       17
       17
        
       

     

       18
       18
        
       in {

     

       19
       19
        
         options.services.confd = {

     

       20
       20
       -
           enable = mkEnableOption "confd service";

     

       20
       20
       +
           enable = mkEnableOption (lib.mdDoc "confd service");

     

       21
       21
        
       

     

       22
       22
        
           backend = mkOption {

     

       23
       23
        
             description = lib.mdDoc "Confd config storage backend to use.";

+1 -1

nixos/modules/services/misc/devmon.nix

···

       8
       8
        
       in {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.devmon = {

     

       11
       11
       -
             enable = mkEnableOption "devmon, an automatic device mounting daemon";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "devmon, an automatic device mounting daemon");

     

       12
       12
        
           };

     

       13
       13
        
         };

     

       14
       14

+3 -3

nixos/modules/services/misc/disnix.nix

···

       17
       17
        
       

     

       18
       18
        
           services.disnix = {

     

       19
       19
        
       

     

       20
       20
       -
             enable = mkEnableOption "Disnix";

     

       20
       20
       +
             enable = mkEnableOption (lib.mdDoc "Disnix");

     

       21
       21
        
       

     

       22
       22
        
             enableMultiUser = mkOption {

     

       23
       23
        
               type = types.bool;

     
···

       25
       25
        
               description = lib.mdDoc "Whether to support multi-user mode by enabling the Disnix D-Bus service";

     

       26
       26
        
             };

     

       27
       27
        
       

     

       28
       28
       -
             useWebServiceInterface = mkEnableOption "the DisnixWebService interface running on Apache Tomcat";

     

       28
       28
       +
             useWebServiceInterface = mkEnableOption (lib.mdDoc "the DisnixWebService interface running on Apache Tomcat");

     

       29
       29
        
       

     

       30
       30
        
             package = mkOption {

     

       31
       31
        
               type = types.path;

     
···

       34
       34
        
               defaultText = literalExpression "pkgs.disnix";

     

       35
       35
        
             };

     

       36
       36
        
       

     

       37
       37
       -
             enableProfilePath = mkEnableOption "exposing the Disnix profiles in the system's PATH";

     

       37
       37
       +
             enableProfilePath = mkEnableOption (lib.mdDoc "exposing the Disnix profiles in the system's PATH");

     

       38
       38
        
       

     

       39
       39
        
             profiles = mkOption {

     

       40
       40
        
               type = types.listOf types.str;

+3 -3

nixos/modules/services/misc/docker-registry.nix

···

       47
       47
        
       

     

       48
       48
        
       in {

     

       49
       49
        
         options.services.dockerRegistry = {

     

       50
       50
       -
           enable = mkEnableOption "Docker Registry";

     

       50
       50
       +
           enable = mkEnableOption (lib.mdDoc "Docker Registry");

     

       51
       51
        
       

     

       52
       52
        
           listenAddress = mkOption {

     

       53
       53
        
             description = lib.mdDoc "Docker registry host or ip to bind to.";

     
···

       76
       76
        
             description = lib.mdDoc "Enable delete for manifests and blobs.";

     

       77
       77
        
           };

     

       78
       78
        
       

     

       79
       79
       -
           enableRedisCache = mkEnableOption "redis as blob cache";

     

       79
       79
       +
           enableRedisCache = mkEnableOption (lib.mdDoc "redis as blob cache");

     

       80
       80
        
       

     

       81
       81
        
           redisUrl = mkOption {

     

       82
       82
        
             type = types.str;

     
···

       98
       98
        
             type = types.attrs;

     

       99
       99
        
           };

     

       100
       100
        
       

     

       101
       101
       -
           enableGarbageCollect = mkEnableOption "garbage collect";

     

       101
       101
       +
           enableGarbageCollect = mkEnableOption (lib.mdDoc "garbage collect");

     

       102
       102
        
       

     

       103
       103
        
           garbageCollectDates = mkOption {

     

       104
       104
        
             default = "daily";

+1 -1

nixos/modules/services/misc/domoticz.nix

···

       12
       12
        
         options = {

     

       13
       13
        
       

     

       14
       14
        
           services.domoticz = {

     

       15
       15
       -
             enable = mkEnableOption pkgDesc;

     

       15
       15
       +
             enable = mkEnableOption (lib.mdDoc pkgDesc);

     

       16
       16
        
       

     

       17
       17
        
             bind = mkOption {

     

       18
       18
        
               type = types.str;

+1 -1

nixos/modules/services/misc/duckling.nix

···

       7
       7
        
       in {

     

       8
       8
        
         options = {

     

       9
       9
        
           services.duckling = {

     

       10
       10
       -
             enable = mkEnableOption "duckling";

     

       10
       10
       +
             enable = mkEnableOption (lib.mdDoc "duckling");

     

       11
       11
        
       

     

       12
       12
        
             port = mkOption {

     

       13
       13
        
               type = types.port;

+1 -1

nixos/modules/services/misc/dwm-status.nix

···

       22
       22
        
       

     

       23
       23
        
           services.dwm-status = {

     

       24
       24
        
       

     

       25
       25
       -
             enable = mkEnableOption "dwm-status user service";

     

       25
       25
       +
             enable = mkEnableOption (lib.mdDoc "dwm-status user service");

     

       26
       26
        
       

     

       27
       27
        
             package = mkOption {

     

       28
       28
        
               type = types.package;

+1 -1

nixos/modules/services/misc/etesync-dav.nix

···

       7
       7
        
       in

     

       8
       8
        
         {

     

       9
       9
        
           options.services.etesync-dav = {

     

       10
       10
       -
             enable = mkEnableOption "etesync-dav";

     

       10
       10
       +
             enable = mkEnableOption (lib.mdDoc "etesync-dav");

     

       11
       11
        
       

     

       12
       12
        
             host = mkOption {

     

       13
       13
        
               type = types.str;

+1 -1

nixos/modules/services/misc/felix.nix

···

       17
       17
        
       

     

       18
       18
        
           services.felix = {

     

       19
       19
        
       

     

       20
       20
       -
             enable = mkEnableOption "the Apache Felix OSGi service";

     

       20
       20
       +
             enable = mkEnableOption (lib.mdDoc "the Apache Felix OSGi service");

     

       21
       21
        
       

     

       22
       22
        
             bundles = mkOption {

     

       23
       23
        
               type = types.listOf types.package;

+1 -1

nixos/modules/services/misc/freeswitch.nix

···

       18
       18
        
       in {

     

       19
       19
        
         options = {

     

       20
       20
        
           services.freeswitch = {

     

       21
       21
       -
             enable = mkEnableOption "FreeSWITCH";

     

       21
       21
       +
             enable = mkEnableOption (lib.mdDoc "FreeSWITCH");

     

       22
       22
        
             enableReload = mkOption {

     

       23
       23
        
               default = false;

     

       24
       24
        
               type = types.bool;

+1 -1

nixos/modules/services/misc/fstrim.nix

···

       11
       11
        
         options = {

     

       12
       12
        
       

     

       13
       13
        
           services.fstrim = {

     

       14
       14
       -
             enable = mkEnableOption "periodic SSD TRIM of mounted partitions in background";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "periodic SSD TRIM of mounted partitions in background");

     

       15
       15
        
       

     

       16
       16
        
             interval = mkOption {

     

       17
       17
        
               type = types.str;

+1 -1

nixos/modules/services/misc/gammu-smsd.nix

···

       53
       53
        
         options = {

     

       54
       54
        
           services.gammu-smsd = {

     

       55
       55
        
       

     

       56
       56
       -
             enable = mkEnableOption "gammu-smsd daemon";

     

       56
       56
       +
             enable = mkEnableOption (lib.mdDoc "gammu-smsd daemon");

     

       57
       57
        
       

     

       58
       58
        
             user = mkOption {

     

       59
       59
        
               type = types.str;

+2 -2

nixos/modules/services/misc/geoipupdate.nix

···

       11
       11
        
       

     

       12
       12
        
         options = {

     

       13
       13
        
           services.geoipupdate = {

     

       14
       14
       -
             enable = lib.mkEnableOption ''

     

       14
       14
       +
             enable = lib.mkEnableOption (lib.mdDoc ''

     

       15
       15
        
               periodic downloading of GeoIP databases using geoipupdate.

     

       16
       16
       -
             '';

     

       16
       16
       +
             '');

     

       17
       17
        
       

     

       18
       18
        
             interval = lib.mkOption {

     

       19
       19
        
               type = lib.types.str;

+2 -2

nixos/modules/services/misc/gitit.nix

···

       49
       49
        
                   haskellPackages.wreq

     

       50
       50
        
                 ]

     

       51
       51
        
               '';

     

       52
       52
       -
               description = ''

     

       52
       52
       +
               description = lib.mdDoc ''

     

       53
       53
        
                 Extra packages available to ghc when running gitit. The

     

       54
       54
        
                 value must be a function which receives the attrset defined

     

       55
       55
       -
                 in <varname>haskellPackages</varname> as the sole argument.

     

       55
       55
       +
                 in {var}`haskellPackages` as the sole argument.

     

       56
       56
        
               '';

     

       57
       57
        
             };

     

       58
       58

+1 -1

nixos/modules/services/misc/greenclip.nix

···

       7
       7
        
       in {

     

       8
       8
        
       

     

       9
       9
        
         options.services.greenclip = {

     

       10
       10
       -
           enable = mkEnableOption "Greenclip daemon";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "Greenclip daemon");

     

       11
       11
        
       

     

       12
       12
        
           package = mkOption {

     

       13
       13
        
             type = types.package;

+2 -2

nixos/modules/services/misc/heisenbridge.nix

···

       23
       23
        
       in

     

       24
       24
        
       {

     

       25
       25
        
         options.services.heisenbridge = {

     

       26
       26
       -
           enable = mkEnableOption "the Matrix to IRC bridge";

     

       26
       26
       +
           enable = mkEnableOption (lib.mdDoc "the Matrix to IRC bridge");

     

       27
       27
        
       

     

       28
       28
        
           package = mkOption {

     

       29
       29
        
             type = types.package;

     
···

       99
       99
        
             };

     

       100
       100
        
           };

     

       101
       101
        
       

     

       102
       102
       -
           identd.enable = mkEnableOption "identd service support";

     

       102
       102
       +
           identd.enable = mkEnableOption (lib.mdDoc "identd service support");

     

       103
       103
        
           identd.port = mkOption {

     

       104
       104
        
             type = types.port;

     

       105
       105
        
             description = lib.mdDoc "identd listen port";

+2 -2

nixos/modules/services/misc/ihaskell.nix

···

       30
       30
        
                   haskellPackages.lens

     

       31
       31
        
                 ]

     

       32
       32
        
               '';

     

       33
       33
       -
               description = ''

     

       33
       33
       +
               description = lib.mdDoc ''

     

       34
       34
        
                 Extra packages available to ghc when running ihaskell. The

     

       35
       35
        
                 value must be a function which receives the attrset defined

     

       36
       36
       -
                 in <varname>haskellPackages</varname> as the sole argument.

     

       36
       36
       +
                 in {var}`haskellPackages` as the sole argument.

     

       37
       37
        
               '';

     

       38
       38
        
             };

     

       39
       39
        
           };

+2 -2

nixos/modules/services/misc/input-remapper.nix

···

       6
       6
        
       {

     

       7
       7
        
         options = {

     

       8
       8
        
           services.input-remapper = {

     

       9
       9
       -
             enable = mkEnableOption "input-remapper, an easy to use tool to change the mapping of your input device buttons.";

     

       9
       9
       +
             enable = mkEnableOption (lib.mdDoc "input-remapper, an easy to use tool to change the mapping of your input device buttons.");

     

       10
       10
        
             package = options.mkPackageOption pkgs "input-remapper" { };

     

       11
       11
       -
             enableUdevRules = mkEnableOption "udev rules added by input-remapper to handle hotplugged devices. Currently disabled by default due to https://github.com/sezanzeb/input-remapper/issues/140";

     

       11
       11
       +
             enableUdevRules = mkEnableOption (lib.mdDoc "udev rules added by input-remapper to handle hotplugged devices. Currently disabled by default due to https://github.com/sezanzeb/input-remapper/issues/140");

     

       12
       12
        
             serviceWantedBy = mkOption {

     

       13
       13
        
               default = [ "graphical.target" ];

     

       14
       14
        
               example = [ "multi-user.target" ];

+1 -1

nixos/modules/services/misc/jackett.nix

···

       9
       9
        
       {

     

       10
       10
        
         options = {

     

       11
       11
        
           services.jackett = {

     

       12
       12
       -
             enable = mkEnableOption "Jackett";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "Jackett");

     

       13
       13
        
       

     

       14
       14
        
             dataDir = mkOption {

     

       15
       15
        
               type = types.str;

+1 -1

nixos/modules/services/misc/jellyfin.nix

···

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.jellyfin = {

     

       11
       11
       -
             enable = mkEnableOption "Jellyfin Media Server";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "Jellyfin Media Server");

     

       12
       12
        
       

     

       13
       13
        
             user = mkOption {

     

       14
       14
        
               type = types.str;

+1 -1

nixos/modules/services/misc/klipper.nix

···

       14
       14
        
         ##### interface

     

       15
       15
        
         options = {

     

       16
       16
        
           services.klipper = {

     

       17
       17
       -
             enable = mkEnableOption "Klipper, the 3D printer firmware";

     

       17
       17
       +
             enable = mkEnableOption (lib.mdDoc "Klipper, the 3D printer firmware");

     

       18
       18
        
       

     

       19
       19
        
             package = mkOption {

     

       20
       20
        
               type = types.package;

+1 -1

nixos/modules/services/misc/leaps.nix

···

       9
       9
        
       {

     

       10
       10
        
         options = {

     

       11
       11
        
           services.leaps = {

     

       12
       12
       -
             enable = mkEnableOption "leaps";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "leaps");

     

       13
       13
        
             port = mkOption {

     

       14
       14
        
               type = types.port;

     

       15
       15
        
               default = 8080;

+1 -1

nixos/modules/services/misc/libreddit.nix

···

       13
       13
        
       {

     

       14
       14
        
         options = {

     

       15
       15
        
           services.libreddit = {

     

       16
       16
       -
             enable = mkEnableOption "Private front-end for Reddit";

     

       16
       16
       +
             enable = mkEnableOption (lib.mdDoc "Private front-end for Reddit");

     

       17
       17
        
       

     

       18
       18
        
             address = mkOption {

     

       19
       19
        
               default = "0.0.0.0";

+1 -1

nixos/modules/services/misc/lidarr.nix

···

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.lidarr = {

     

       11
       11
       -
             enable = mkEnableOption "Lidarr";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "Lidarr");

     

       12
       12
        
       

     

       13
       13
        
             dataDir = mkOption {

     

       14
       14
        
               type = types.str;

+2 -2

nixos/modules/services/misc/lifecycled.nix

···

       25
       25
        
       

     

       26
       26
        
         options = {

     

       27
       27
        
           services.lifecycled = {

     

       28
       28
       -
             enable = mkEnableOption "lifecycled";

     

       28
       28
       +
             enable = mkEnableOption (lib.mdDoc "lifecycled");

     

       29
       29
        
       

     

       30
       30
        
             queueCleaner = {

     

       31
       31
       -
               enable = mkEnableOption "lifecycled-queue-cleaner";

     

       31
       31
       +
               enable = mkEnableOption (lib.mdDoc "lifecycled-queue-cleaner");

     

       32
       32
        
       

     

       33
       33
        
               frequency = mkOption {

     

       34
       34
        
                 type = types.str;

+1 -1

nixos/modules/services/misc/logkeys.nix

···

       6
       6
        
         cfg = config.services.logkeys;

     

       7
       7
        
       in {

     

       8
       8
        
         options.services.logkeys = {

     

       9
       9
       -
           enable = mkEnableOption "logkeys service";

     

       9
       9
       +
           enable = mkEnableOption (lib.mdDoc "logkeys service");

     

       10
       10
        
       

     

       11
       11
        
           device = mkOption {

     

       12
       12
        
             description = lib.mdDoc "Use the given device as keyboard input event device instead of /dev/input/eventX default.";

+1 -1

nixos/modules/services/misc/mbpfan.nix

···

       10
       10
        
       

     

       11
       11
        
       in {

     

       12
       12
        
         options.services.mbpfan = {

     

       13
       13
       -
           enable = mkEnableOption "mbpfan, fan controller daemon for Apple Macs and MacBooks";

     

       13
       13
       +
           enable = mkEnableOption (lib.mdDoc "mbpfan, fan controller daemon for Apple Macs and MacBooks");

     

       14
       14
        
       

     

       15
       15
        
           package = mkOption {

     

       16
       16
        
             type = types.package;

+1 -1

nixos/modules/services/misc/metabase.nix

···

       13
       13
        
         options = {

     

       14
       14
        
       

     

       15
       15
        
           services.metabase = {

     

       16
       16
       -
             enable = mkEnableOption "Metabase service";

     

       16
       16
       +
             enable = mkEnableOption (lib.mdDoc "Metabase service");

     

       17
       17
        
       

     

       18
       18
        
             listen = {

     

       19
       19
        
               ip = mkOption {

+1 -1

nixos/modules/services/misc/moonraker.nix

···

       14
       14
        
       in {

     

       15
       15
        
         options = {

     

       16
       16
        
           services.moonraker = {

     

       17
       17
       -
             enable = mkEnableOption "Moonraker, an API web server for Klipper";

     

       17
       17
       +
             enable = mkEnableOption (lib.mdDoc "Moonraker, an API web server for Klipper");

     

       18
       18
        
       

     

       19
       19
        
             klipperSocket = mkOption {

     

       20
       20
        
               type = types.path;

+2 -2

nixos/modules/services/misc/mx-puppet-discord.nix

···

       12
       12
        
       in {

     

       13
       13
        
         options = {

     

       14
       14
        
           services.mx-puppet-discord = {

     

       15
       15
       -
             enable = mkEnableOption ''

     

       15
       15
       +
             enable = mkEnableOption (lib.mdDoc ''

     

       16
       16
        
               mx-puppet-discord is a discord puppeting bridge for matrix.

     

       17
       17
        
               It handles bridging private and group DMs, as well as Guilds (servers)

     

       18
       18
       -
             '';

     

       18
       18
       +
             '');

     

       19
       19
        
       

     

       20
       20
        
             settings = mkOption rec {

     

       21
       21
        
               apply = recursiveUpdate default;

+1 -1

nixos/modules/services/misc/n8n.nix

···

       10
       10
        
       {

     

       11
       11
        
         options.services.n8n = {

     

       12
       12
        
       

     

       13
       13
       -
           enable = mkEnableOption "n8n server";

     

       13
       13
       +
           enable = mkEnableOption (lib.mdDoc "n8n server");

     

       14
       14
        
       

     

       15
       15
        
           openFirewall = mkOption {

     

       16
       16
        
             type = types.bool;

+1 -1

nixos/modules/services/misc/nitter.nix

···

       47
       47
        
       {

     

       48
       48
        
         options = {

     

       49
       49
        
           services.nitter = {

     

       50
       50
       -
             enable = mkEnableOption "If enabled, start Nitter.";

     

       50
       50
       +
             enable = mkEnableOption (lib.mdDoc "If enabled, start Nitter.");

     

       51
       51
        
       

     

       52
       52
        
             package = mkOption {

     

       53
       53
        
               default = pkgs.nitter;

+8 -8

nixos/modules/services/misc/nix-daemon.nix

···

       231
       231
        
                     type = types.nullOr types.str;

     

       232
       232
        
                     default = null;

     

       233
       233
        
                     example = "x86_64-linux";

     

       234
       234
       -
                     description = ''

     

       234
       234
       +
                     description = lib.mdDoc ''

     

       235
       235
        
                       The system type the build machine can execute derivations on.

     

       236
       236
       -
                       Either this attribute or <varname>systems</varname> must be

     

       237
       237
       -
                       present, where <varname>system</varname> takes precedence if

     

       236
       236
       +
                       Either this attribute or {var}`systems` must be

     

       237
       237
       +
                       present, where {var}`system` takes precedence if

     

       238
       238
        
                       both are set.

     

       239
       239
        
                     '';

     

       240
       240
        
                   };

     
···

       242
       242
        
                     type = types.listOf types.str;

     

       243
       243
        
                     default = [ ];

     

       244
       244
        
                     example = [ "x86_64-linux" "aarch64-linux" ];

     

       245
       245
       -
                     description = ''

     

       245
       245
       +
                     description = lib.mdDoc ''

     

       246
       246
        
                       The system types the build machine can execute derivations on.

     

       247
       247
       -
                       Either this attribute or <varname>system</varname> must be

     

       248
       248
       -
                       present, where <varname>system</varname> takes precedence if

     

       247
       247
       +
                       Either this attribute or {var}`system` must be

     

       248
       248
       +
                       present, where {var}`system` takes precedence if

     

       249
       249
        
                       both are set.

     

       250
       250
        
                     '';

     

       251
       251
        
                   };

     
···

       297
       297
        
                     type = types.listOf types.str;

     

       298
       298
        
                     default = [ ];

     

       299
       299
        
                     example = [ "big-parallel" ];

     

       300
       300
       -
                     description = ''

     

       300
       300
       +
                     description = lib.mdDoc ''

     

       301
       301
        
                       A list of features mandatory for this builder. The builder will

     

       302
       302
        
                       be ignored for derivations that don't require all features in

     

       303
       303
        
                       this list. All mandatory features are automatically included in

     

       304
       304
       -
                       <varname>supportedFeatures</varname>.

     

       304
       304
       +
                       {var}`supportedFeatures`.

     

       305
       305
        
                     '';

     

       306
       306
        
                   };

     

       307
       307
        
                   supportedFeatures = mkOption {

+1 -1

nixos/modules/services/misc/novacomd.nix

···

       10
       10
        
       

     

       11
       11
        
         options = {

     

       12
       12
        
           services.novacomd = {

     

       13
       13
       -
             enable = mkEnableOption "Novacom service for connecting to WebOS devices";

     

       13
       13
       +
             enable = mkEnableOption (lib.mdDoc "Novacom service for connecting to WebOS devices");

     

       14
       14
        
           };

     

       15
       15
        
         };

     

       16
       16

+1 -1

nixos/modules/services/misc/nzbget.nix

···

       25
       25
        
       

     

       26
       26
        
         options = {

     

       27
       27
        
           services.nzbget = {

     

       28
       28
       -
             enable = mkEnableOption "NZBGet";

     

       28
       28
       +
             enable = mkEnableOption (lib.mdDoc "NZBGet");

     

       29
       29
        
       

     

       30
       30
        
             user = mkOption {

     

       31
       31
        
               type = types.str;

+1 -1

nixos/modules/services/misc/nzbhydra2.nix

···

       7
       7
        
       in {

     

       8
       8
        
         options = {

     

       9
       9
        
           services.nzbhydra2 = {

     

       10
       10
       -
             enable = mkEnableOption "NZBHydra2";

     

       10
       10
       +
             enable = mkEnableOption (lib.mdDoc "NZBHydra2");

     

       11
       11
        
       

     

       12
       12
        
             dataDir = mkOption {

     

       13
       13
        
               type = types.str;

+1 -1

nixos/modules/services/misc/octoprint.nix

···

       29
       29
        
       

     

       30
       30
        
           services.octoprint = {

     

       31
       31
        
       

     

       32
       32
       -
             enable = mkEnableOption "OctoPrint, web interface for 3D printers";

     

       32
       32
       +
             enable = mkEnableOption (lib.mdDoc "OctoPrint, web interface for 3D printers");

     

       33
       33
        
       

     

       34
       34
        
             host = mkOption {

     

       35
       35
        
               type = types.str;

+3 -3

nixos/modules/services/misc/ombi.nix

···

       7
       7
        
       in {

     

       8
       8
        
         options = {

     

       9
       9
        
           services.ombi = {

     

       10
       10
       -
             enable = mkEnableOption ''

     

       10
       10
       +
             enable = mkEnableOption (lib.mdDoc ''

     

       11
       11
        
               Ombi.

     

       12
       12
       -
               Optionally see <link xlink:href="https://docs.ombi.app/info/reverse-proxy"/>

     

       12
       12
       +
               Optionally see <https://docs.ombi.app/info/reverse-proxy>

     

       13
       13
        
               on how to set up a reverse proxy

     

       14
       14
       -
             '';

     

       14
       14
       +
             '');

     

       15
       15
        
       

     

       16
       16
        
             dataDir = mkOption {

     

       17
       17
        
               type = types.str;

+1 -1

nixos/modules/services/misc/owncast.nix

···

       5
       5
        
       

     

       6
       6
        
         options.services.owncast = {

     

       7
       7
        
       

     

       8
       8
       -
           enable = mkEnableOption "owncast";

     

       8
       8
       +
           enable = mkEnableOption (lib.mdDoc "owncast");

     

       9
       9
        
       

     

       10
       10
        
           dataDir = mkOption {

     

       11
       11
        
             type = types.str;

+2 -2

nixos/modules/services/misc/packagekit.nix

···

       39
       39
        
         ];

     

       40
       40
        
       

     

       41
       41
        
         options.services.packagekit = {

     

       42
       42
       -
           enable = mkEnableOption ''

     

       42
       42
       +
           enable = mkEnableOption (lib.mdDoc ''

     

       43
       43
        
             PackageKit provides a cross-platform D-Bus abstraction layer for

     

       44
       44
        
             installing software. Software utilizing PackageKit can install

     

       45
       45
        
             software regardless of the package manager.

     

       46
       46
       -
           '';

     

       46
       46
       +
           '');

     

       47
       47
        
       

     

       48
       48
        
           settings = mkOption {

     

       49
       49
        
             type = iniFmt.type;

+1 -1

nixos/modules/services/misc/persistent-evdev.nix

···

       11
       11
        
       in

     

       12
       12
        
       {

     

       13
       13
        
         options.services.persistent-evdev = {

     

       14
       14
       -
           enable = lib.mkEnableOption "virtual input devices that persist even if the backing device is hotplugged";

     

       14
       14
       +
           enable = lib.mkEnableOption (lib.mdDoc "virtual input devices that persist even if the backing device is hotplugged");

     

       15
       15
        
       

     

       16
       16
        
           devices = lib.mkOption {

     

       17
       17
        
             default = {};

+1 -1

nixos/modules/services/misc/pinnwand.nix

···

       10
       10
        
       in

     

       11
       11
        
       {

     

       12
       12
        
         options.services.pinnwand = {

     

       13
       13
       -
           enable = mkEnableOption "Pinnwand";

     

       13
       13
       +
           enable = mkEnableOption (lib.mdDoc "Pinnwand");

     

       14
       14
        
       

     

       15
       15
        
           port = mkOption {

     

       16
       16
        
             type = types.port;

+1 -1

nixos/modules/services/misc/plex.nix

···

       12
       12
        
       

     

       13
       13
        
         options = {

     

       14
       14
        
           services.plex = {

     

       15
       15
       -
             enable = mkEnableOption "Plex Media Server";

     

       15
       15
       +
             enable = mkEnableOption (lib.mdDoc "Plex Media Server");

     

       16
       16
        
       

     

       17
       17
        
             dataDir = mkOption {

     

       18
       18
        
               type = types.str;

+1 -1

nixos/modules/services/misc/plikd.nix

···

       11
       11
        
       {

     

       12
       12
        
         options = {

     

       13
       13
        
           services.plikd = {

     

       14
       14
       -
             enable = mkEnableOption "the plikd server";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "the plikd server");

     

       15
       15
        
       

     

       16
       16
        
             openFirewall = mkOption {

     

       17
       17
        
               type = types.bool;

+1 -1

nixos/modules/services/misc/podgrab.nix

···

       4
       4
        
       in

     

       5
       5
        
       {

     

       6
       6
        
         options.services.podgrab = with lib; {

     

       7
       7
       -
           enable = mkEnableOption "Podgrab, a self-hosted podcast manager";

     

       7
       7
       +
           enable = mkEnableOption (lib.mdDoc "Podgrab, a self-hosted podcast manager");

     

       8
       8
        
       

     

       9
       9
        
           passwordFile = mkOption {

     

       10
       10
        
             type = with types; nullOr str;

+1 -1

nixos/modules/services/misc/polaris.nix

···

       11
       11
        
       {

     

       12
       12
        
         options = {

     

       13
       13
        
           services.polaris = {

     

       14
       14
       -
             enable = mkEnableOption "Polaris Music Server";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "Polaris Music Server");

     

       15
       15
        
       

     

       16
       16
        
             package = mkPackageOption pkgs "polaris" { };

     

       17
       17

+27 -27

nixos/modules/services/misc/portunus.nix

···

       8
       8
        
       in

     

       9
       9
        
       {

     

       10
       10
        
         options.services.portunus = {

     

       11
       11
       -
           enable = mkEnableOption "Portunus, a self-contained user/group management and authentication service for LDAP";

     

       11
       11
       +
           enable = mkEnableOption (lib.mdDoc "Portunus, a self-contained user/group management and authentication service for LDAP");

     

       12
       12
        
       

     

       13
       13
        
           domain = mkOption {

     

       14
       14
        
             type = types.str;

     

       15
       15
        
             example = "sso.example.com";

     

       16
       16
       -
             description = "Subdomain which gets reverse proxied to Portunus webserver.";

     

       16
       16
       +
             description = lib.mdDoc "Subdomain which gets reverse proxied to Portunus webserver.";

     

       17
       17
        
           };

     

       18
       18
        
       

     

       19
       19
        
           port = mkOption {

     

       20
       20
        
             type = types.port;

     

       21
       21
        
             default = 8080;

     

       22
       22
       -
             description = ''

     

       22
       22
       +
             description = lib.mdDoc ''

     

       23
       23
        
               Port where the Portunus webserver should listen on.

     

       24
       24
        
       

     

       25
       25
        
               This must be put behind a TLS-capable reverse proxy because Portunus only listens on localhost.

     
···

       30
       30
        
             type = types.package;

     

       31
       31
        
             default = pkgs.portunus;

     

       32
       32
        
             defaultText = "pkgs.portunus";

     

       33
       33
       -
             description = "The Portunus package to use.";

     

       33
       33
       +
             description = lib.mdDoc "The Portunus package to use.";

     

       34
       34
        
           };

     

       35
       35
        
       

     

       36
       36
        
           seedPath = mkOption {

     

       37
       37
        
             type = types.nullOr types.path;

     

       38
       38
        
             default = null;

     

       39
       39
       -
             description = ''

     

       39
       39
       +
             description = lib.mdDoc ''

     

       40
       40
        
               Path to a portunus seed file in json format.

     

       41
       41
       -
               See <link xlink:href="https://github.com/majewsky/portunus#seeding-users-and-groups-from-static-configuration"/> for available options.

     

       41
       41
       +
               See <https://github.com/majewsky/portunus#seeding-users-and-groups-from-static-configuration> for available options.

     

       42
       42
        
             '';

     

       43
       43
        
           };

     

       44
       44
        
       

     

       45
       45
        
           stateDir = mkOption {

     

       46
       46
        
             type = types.path;

     

       47
       47
        
             default = "/var/lib/portunus";

     

       48
       48
       -
             description = "Path where Portunus stores its state.";

     

       48
       48
       +
             description = lib.mdDoc "Path where Portunus stores its state.";

     

       49
       49
        
           };

     

       50
       50
        
       

     

       51
       51
        
           user = mkOption {

     

       52
       52
        
             type = types.str;

     

       53
       53
        
             default = "portunus";

     

       54
       54
       -
             description = "User account under which Portunus runs its webserver.";

     

       54
       54
       +
             description = lib.mdDoc "User account under which Portunus runs its webserver.";

     

       55
       55
        
           };

     

       56
       56
        
       

     

       57
       57
        
           group = mkOption {

     

       58
       58
        
             type = types.str;

     

       59
       59
        
             default = "portunus";

     

       60
       60
       -
             description = "Group account under which Portunus runs its webserver.";

     

       60
       60
       +
             description = lib.mdDoc "Group account under which Portunus runs its webserver.";

     

       61
       61
        
           };

     

       62
       62
        
       

     

       63
       63
        
           dex = {

     

       64
       64
       -
             enable = mkEnableOption ''

     

       64
       64
       +
             enable = mkEnableOption (lib.mdDoc ''

     

       65
       65
        
               Dex ldap connector.

     

       66
       66
        
       

     

       67
       67
        
               To activate dex, first a search user must be created in the Portunus web ui

     

       68
       68
       -
               and then the password must to be set as the <literal>DEX_SEARCH_USER_PASSWORD</literal> environment variable

     

       69
       69
       -
               in the <xref linkend="opt-services.dex.environmentFile"/> setting.

     

       70
       70
       -
             '';

     

       68
       68
       +
               and then the password must to be set as the `DEX_SEARCH_USER_PASSWORD` environment variable

     

       69
       69
       +
               in the [](#opt-services.dex.environmentFile) setting.

     

       70
       70
       +
             '');

     

       71
       71
        
       

     

       72
       72
        
             oidcClients = mkOption {

     

       73
       73
        
               type = types.listOf (types.submodule {

     

       74
       74
        
                 options = {

     

       75
       75
        
                   callbackURL = mkOption {

     

       76
       76
        
                     type = types.str;

     

       77
       77
       -
                     description = "URL where the OIDC client should redirect";

     

       77
       77
       +
                     description = lib.mdDoc "URL where the OIDC client should redirect";

     

       78
       78
        
                   };

     

       79
       79
        
                   id = mkOption {

     

       80
       80
        
                     type = types.str;

     

       81
       81
       -
                     description = "ID of the OIDC client";

     

       81
       81
       +
                     description = lib.mdDoc "ID of the OIDC client";

     

       82
       82
        
                   };

     

       83
       83
        
                 };

     

       84
       84
        
               });

     
···

       89
       89
        
                   id = "service";

     

       90
       90
        
                 }

     

       91
       91
        
               ];

     

       92
       92
       -
               description = ''

     

       92
       92
       +
               description = lib.mdDoc ''

     

       93
       93
        
                 List of OIDC clients.

     

       94
       94
        
       

     

       95
       95
       -
                 The OIDC secret must be set as the <literal>DEX_CLIENT_''${id}</literal> environment variable

     

       96
       96
       -
                 in the <xref linkend="opt-services.dex.environmentFile"/> setting.

     

       95
       95
       +
                 The OIDC secret must be set as the `DEX_CLIENT_''${id}` environment variable

     

       96
       96
       +
                 in the [](#opt-services.dex.environmentFile) setting.

     

       97
       97
        
               '';

     

       98
       98
        
             };

     

       99
       99
        
       

     

       100
       100
        
             port = mkOption {

     

       101
       101
        
               type = types.port;

     

       102
       102
        
               default = 5556;

     

       103
       103
       -
               description = "Port where dex should listen on.";

     

       103
       103
       +
               description = lib.mdDoc "Port where dex should listen on.";

     

       104
       104
        
             };

     

       105
       105
        
           };

     

       106
       106
        
       

     
···

       109
       109
        
               type = types.package;

     

       110
       110
        
               default = pkgs.openldap;

     

       111
       111
        
               defaultText = "pkgs.openldap";

     

       112
       112
       -
               description = "The OpenLDAP package to use.";

     

       112
       112
       +
               description = lib.mdDoc "The OpenLDAP package to use.";

     

       113
       113
        
             };

     

       114
       114
        
       

     

       115
       115
        
             searchUserName = mkOption {

     

       116
       116
        
               type = types.str;

     

       117
       117
        
               default = "";

     

       118
       118
        
               example = "admin";

     

       119
       119
       -
               description = ''

     

       119
       119
       +
               description = lib.mdDoc ''

     

       120
       120
        
                 The login name of the search user.

     

       121
       121
        
                 This user account must be configured in Portunus either manually or via seeding.

     

       122
       122
        
               '';

     
···

       125
       125
        
             suffix = mkOption {

     

       126
       126
        
               type = types.str;

     

       127
       127
        
               example = "dc=example,dc=org";

     

       128
       128
       -
               description = ''

     

       128
       128
       +
               description = lib.mdDoc ''

     

       129
       129
        
                 The DN of the topmost entry in your LDAP directory.

     

       130
       130
        
                 Please refer to the Portunus documentation for more information on how this impacts the structure of the LDAP directory.

     

       131
       131
        
               '';

     
···

       134
       134
        
             tls = mkOption {

     

       135
       135
        
               type = types.bool;

     

       136
       136
        
               default = false;

     

       137
       137
       -
               description = ''

     

       137
       137
       +
               description = lib.mdDoc ''

     

       138
       138
        
                 Wether to enable LDAPS protocol.

     

       139
       139
       -
                 This also adds two entries to the <literal>/etc/hosts</literal> file to point <xref linkend="opt-services.portunus.domain"/> to localhost,

     

       139
       139
       +
                 This also adds two entries to the `/etc/hosts` file to point [](#opt-services.portunus.domain) to localhost,

     

       140
       140
        
                 so that CLIs and programs can use ldaps protocol and verify the certificate without opening the firewall port for the protocol.

     

       141
       141
        
       

     

       142
       142
       -
                 This requires a TLS certificate for <xref linkend="opt-services.portunus.domain"/> to be configured via <xref linkend="opt-security.acme.certs"/>.

     

       142
       142
       +
                 This requires a TLS certificate for [](#opt-services.portunus.domain) to be configured via [](#opt-security.acme.certs).

     

       143
       143
        
               '';

     

       144
       144
        
             };

     

       145
       145
        
       

     

       146
       146
        
             user = mkOption {

     

       147
       147
        
               type = types.str;

     

       148
       148
        
               default = "openldap";

     

       149
       149
       -
               description = "User account under which Portunus runs its LDAP server.";

     

       149
       149
       +
               description = lib.mdDoc "User account under which Portunus runs its LDAP server.";

     

       150
       150
        
             };

     

       151
       151
        
       

     

       152
       152
        
             group = mkOption {

     

       153
       153
        
               type = types.str;

     

       154
       154
        
               default = "openldap";

     

       155
       155
       -
               description = "Group account under which Portunus runs its LDAP server.";

     

       155
       155
       +
               description = lib.mdDoc "Group account under which Portunus runs its LDAP server.";

     

       156
       156
        
             };

     

       157
       157
        
           };

     

       158
       158
        
         };

+1 -1

nixos/modules/services/misc/prowlarr.nix

···

       9
       9
        
       {

     

       10
       10
        
         options = {

     

       11
       11
        
           services.prowlarr = {

     

       12
       12
       -
             enable = mkEnableOption "Prowlarr";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "Prowlarr");

     

       13
       13
        
       

     

       14
       14
        
             openFirewall = mkOption {

     

       15
       15
        
               type = types.bool;

+1 -1

nixos/modules/services/misc/radarr.nix

···

       9
       9
        
       {

     

       10
       10
        
         options = {

     

       11
       11
        
           services.radarr = {

     

       12
       12
       -
             enable = mkEnableOption "Radarr";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "Radarr");

     

       13
       13
        
       

     

       14
       14
        
             package = mkOption {

     

       15
       15
        
               description = lib.mdDoc "Radarr package to use";

+1 -1

nixos/modules/services/misc/redmine.nix

···

       49
       49
        
         # interface

     

       50
       50
        
         options = {

     

       51
       51
        
           services.redmine = {

     

       52
       52
       -
             enable = mkEnableOption "Redmine";

     

       52
       52
       +
             enable = mkEnableOption (lib.mdDoc "Redmine");

     

       53
       53
        
       

     

       54
       54
        
             package = mkOption {

     

       55
       55
        
               type = types.package;

+1 -1

nixos/modules/services/misc/ripple-data-api.nix

···

       35
       35
        
       in {

     

       36
       36
        
         options = {

     

       37
       37
        
           services.rippleDataApi = {

     

       38
       38
       -
             enable = mkEnableOption "ripple data api";

     

       38
       38
       +
             enable = mkEnableOption (lib.mdDoc "ripple data api");

     

       39
       39
        
       

     

       40
       40
        
             port = mkOption {

     

       41
       41
        
               description = lib.mdDoc "Ripple data api port";

+2 -2

nixos/modules/services/misc/rippled.nix

···

       207
       207
        
       

     

       208
       208
        
         options = {

     

       209
       209
        
           services.rippled = {

     

       210
       210
       -
             enable = mkEnableOption "rippled";

     

       210
       210
       +
             enable = mkEnableOption (lib.mdDoc "rippled");

     

       211
       211
        
       

     

       212
       212
        
             package = mkOption {

     

       213
       213
        
               description = lib.mdDoc "Which rippled package to use.";

     
···

       375
       375
        
             };

     

       376
       376
        
       

     

       377
       377
        
             statsd = {

     

       378
       378
       -
               enable = mkEnableOption "statsd monitoring for rippled";

     

       378
       378
       +
               enable = mkEnableOption (lib.mdDoc "statsd monitoring for rippled");

     

       379
       379
        
       

     

       380
       380
        
               address = mkOption {

     

       381
       381
        
                 description = lib.mdDoc "The UDP address and port of the listening StatsD server.";

+1 -1

nixos/modules/services/misc/rmfakecloud.nix

···

       9
       9
        
       in {

     

       10
       10
        
         options = {

     

       11
       11
        
           services.rmfakecloud = {

     

       12
       12
       -
             enable = mkEnableOption "rmfakecloud remarkable self-hosted cloud";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "rmfakecloud remarkable self-hosted cloud");

     

       13
       13
        
       

     

       14
       14
        
             package = mkOption {

     

       15
       15
        
               type = types.package;

+1 -1

nixos/modules/services/misc/safeeyes.nix

···

       16
       16
        
       

     

       17
       17
        
           services.safeeyes = {

     

       18
       18
        
       

     

       19
       19
       -
             enable = mkEnableOption "the safeeyes OSGi service";

     

       19
       19
       +
             enable = mkEnableOption (lib.mdDoc "the safeeyes OSGi service");

     

       20
       20
        
       

     

       21
       21
        
           };

     

       22
       22

+1 -1

nixos/modules/services/misc/signald.nix

···

       8
       8
        
       in

     

       9
       9
        
       {

     

       10
       10
        
         options.services.signald = {

     

       11
       11
       -
           enable = mkEnableOption "the signald service";

     

       11
       11
       +
           enable = mkEnableOption (lib.mdDoc "the signald service");

     

       12
       12
        
       

     

       13
       13
        
           user = mkOption {

     

       14
       14
        
             type = types.str;

+1 -1

nixos/modules/services/misc/sonarr.nix

···

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.sonarr = {

     

       11
       11
       -
             enable = mkEnableOption "Sonarr";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "Sonarr");

     

       12
       12
        
       

     

       13
       13
        
             dataDir = mkOption {

     

       14
       14
        
               type = types.str;

+16 -16

nixos/modules/services/misc/sourcehut/default.nix

···

       67
       67
        
             type = types.str;

     

       68
       68
        
             default = "postgresql:///localhost?user=${srv}srht&host=/run/postgresql";

     

       69
       69
        
           };

     

       70
       70
       -
           migrate-on-upgrade = mkEnableOption "automatic migrations on package upgrade" // { default = true; };

     

       70
       70
       +
           migrate-on-upgrade = mkEnableOption (lib.mdDoc "automatic migrations on package upgrade") // { default = true; };

     

       71
       71
        
           oauth-client-id = mkOption {

     

       72
       72
        
             description = lib.mdDoc "${srv}.sr.ht's OAuth client id for meta.sr.ht.";

     

       73
       73
        
             type = types.str;

     
···

       108
       108
        
       in

     

       109
       109
        
       {

     

       110
       110
        
         options.services.sourcehut = {

     

       111
       111
       -
           enable = mkEnableOption ''

     

       111
       111
       +
           enable = mkEnableOption (lib.mdDoc ''

     

       112
       112
        
             sourcehut - git hosting, continuous integration, mailing list, ticket tracking,

     

       113
       113
        
             task dispatching, wiki and account management services

     

       114
       114
       -
           '';

     

       114
       114
       +
           '');

     

       115
       115
        
       

     

       116
       116
        
           services = mkOption {

     

       117
       117
        
             type = with types; listOf (enum

     
···

       139
       139
        
           };

     

       140
       140
        
       

     

       141
       141
        
           minio = {

     

       142
       142
       -
             enable = mkEnableOption ''local minio integration'';

     

       142
       142
       +
             enable = mkEnableOption (lib.mdDoc ''local minio integration'');

     

       143
       143
        
           };

     

       144
       144
        
       

     

       145
       145
        
           nginx = {

     

       146
       146
       -
             enable = mkEnableOption ''local nginx integration'';

     

       146
       146
       +
             enable = mkEnableOption (lib.mdDoc ''local nginx integration'');

     

       147
       147
        
             virtualHost = mkOption {

     

       148
       148
        
               type = types.attrs;

     

       149
       149
        
               default = {};

     
···

       152
       152
        
           };

     

       153
       153
        
       

     

       154
       154
        
           postfix = {

     

       155
       155
       -
             enable = mkEnableOption ''local postfix integration'';

     

       155
       155
       +
             enable = mkEnableOption (lib.mdDoc ''local postfix integration'');

     

       156
       156
        
           };

     

       157
       157
        
       

     

       158
       158
        
           postgresql = {

     

       159
       159
       -
             enable = mkEnableOption ''local postgresql integration'';

     

       159
       159
       +
             enable = mkEnableOption (lib.mdDoc ''local postgresql integration'');

     

       160
       160
        
           };

     

       161
       161
        
       

     

       162
       162
        
           redis = {

     

       163
       163
       -
             enable = mkEnableOption ''local redis integration in a dedicated redis-server'';

     

       163
       163
       +
             enable = mkEnableOption (lib.mdDoc ''local redis integration in a dedicated redis-server'');

     

       164
       164
        
           };

     

       165
       165
        
       

     

       166
       166
        
           settings = mkOption {

     
···

       308
       308
        
                 oauth-client-secret = mkOptionNullOrStr "OAuth client secret.";

     

       309
       309
        
               };

     

       310
       310
        
               options."dispatch.sr.ht::gitlab" = {

     

       311
       311
       -
                 enabled = mkEnableOption "GitLab integration";

     

       311
       311
       +
                 enabled = mkEnableOption (lib.mdDoc "GitLab integration");

     

       312
       312
        
                 canonical-upstream = mkOption {

     

       313
       313
        
                   type = types.str;

     

       314
       314
        
                   description = lib.mdDoc "Canonical upstream.";

     
···

       328
       328
        
               };

     

       329
       329
        
       

     

       330
       330
        
               options."builds.sr.ht" = commonServiceSettings "builds" // {

     

       331
       331
       -
                 allow-free = mkEnableOption "nonpaying users to submit builds";

     

       331
       331
       +
                 allow-free = mkEnableOption (lib.mdDoc "nonpaying users to submit builds");

     

       332
       332
        
                 redis = mkOption {

     

       333
       333
        
                   description = lib.mdDoc "The Redis connection used for the Celery worker.";

     

       334
       334
        
                   type = types.str;

     
···

       465
       465
        
               };

     

       466
       466
        
       

     

       467
       467
        
               options."lists.sr.ht" = commonServiceSettings "lists" // {

     

       468
       468
       -
                 allow-new-lists = mkEnableOption "Allow creation of new lists.";

     

       468
       468
       +
                 allow-new-lists = mkEnableOption (lib.mdDoc "Allow creation of new lists.");

     

       469
       469
        
                 notify-from = mkOption {

     

       470
       470
        
                   description = lib.mdDoc "Outgoing email for notifications generated by users.";

     

       471
       471
        
                   type = types.str;

     
···

       539
       539
        
                   type = types.str;

     

       540
       540
        
                   default = "redis+socket:///run/redis-sourcehut-metasrht/redis.sock?virtual_host=1";

     

       541
       541
        
                 };

     

       542
       542
       -
                 welcome-emails = mkEnableOption "sending stock sourcehut welcome emails after signup";

     

       542
       542
       +
                 welcome-emails = mkEnableOption (lib.mdDoc "sending stock sourcehut welcome emails after signup");

     

       543
       543
        
               };

     

       544
       544
        
               options."meta.sr.ht::api" = {

     

       545
       545
        
                 internal-ipnet = mkOption {

     
···

       560
       560
        
                 example = { "git.sr.ht" = 12345; };

     

       561
       561
        
               };

     

       562
       562
        
               options."meta.sr.ht::billing" = {

     

       563
       563
       -
                 enabled = mkEnableOption "the billing system";

     

       563
       563
       +
                 enabled = mkEnableOption (lib.mdDoc "the billing system");

     

       564
       564
        
                 stripe-public-key = mkOptionNullOrStr "Public key for Stripe. Get your keys at https://dashboard.stripe.com/account/apikeys";

     

       565
       565
        
                 stripe-secret-key = mkOptionNullOrStr ''

     

       566
       566
        
                   An absolute file path (which should be outside the Nix-store)

     
···

       570
       570
        
                 };

     

       571
       571
        
               };

     

       572
       572
        
               options."meta.sr.ht::settings" = {

     

       573
       573
       -
                 registration = mkEnableOption "public registration";

     

       573
       573
       +
                 registration = mkEnableOption (lib.mdDoc "public registration");

     

       574
       574
        
                 onboarding-redirect = mkOption {

     

       575
       575
        
                   description = lib.mdDoc "Where to redirect new users upon registration.";

     

       576
       576
        
                   type = types.str;

     
···

       601
       601
        
                   default = 1024;

     

       602
       602
        
                 };

     

       603
       603
        
                 user-domain = mkOption {

     

       604
       604
       -
                   description = ''

     

       604
       604
       +
                   description = lib.mdDoc ''

     

       605
       605
        
                     Configures the user domain, if enabled.

     

       606
       606
       -
                     All users are given &lt;username&gt;.this.domain.

     

       606
       606
       +
                     All users are given \<username\>.this.domain.

     

       607
       607
        
                   '';

     

       608
       608
        
                   type = with types; nullOr str;

     

       609
       609
        
                   default = null;

+1 -1

nixos/modules/services/misc/sourcehut/service.nix

···

       117
       117
        
       in

     

       118
       118
        
       {

     

       119
       119
        
         options.services.sourcehut.${srv} = {

     

       120
       120
       -
           enable = mkEnableOption "${srv} service";

     

       120
       120
       +
           enable = mkEnableOption (lib.mdDoc "${srv} service");

     

       121
       121
        
       

     

       122
       122
        
           user = mkOption {

     

       123
       123
        
             type = types.str;

+1 -1

nixos/modules/services/misc/spice-vdagentd.nix

···

       7
       7
        
       {

     

       8
       8
        
         options = {

     

       9
       9
        
           services.spice-vdagentd = {

     

       10
       10
       -
             enable = mkEnableOption "Spice guest vdagent daemon";

     

       10
       10
       +
             enable = mkEnableOption (lib.mdDoc "Spice guest vdagent daemon");

     

       11
       11
        
           };

     

       12
       12
        
         };

     

       13
       13

+2 -2

nixos/modules/services/misc/spice-webdavd.nix

···

       7
       7
        
       {

     

       8
       8
        
         options = {

     

       9
       9
        
           services.spice-webdavd = {

     

       10
       10
       -
             enable = mkEnableOption "the spice guest webdav proxy daemon";

     

       10
       10
       +
             enable = mkEnableOption (lib.mdDoc "the spice guest webdav proxy daemon");

     

       11
       11
        
       

     

       12
       12
        
             package = mkOption {

     

       13
       13
        
               default = pkgs.phodav;

     

       14
       14
        
               defaultText = literalExpression "pkgs.phodav";

     

       15
       15
        
               type = types.package;

     

       16
       16
       -
               description = "spice-webdavd provider package to use.";

     

       16
       16
       +
               description = lib.mdDoc "spice-webdavd provider package to use.";

     

       17
       17
        
             };

     

       18
       18
        
           };

     

       19
       19
        
         };

+1 -1

nixos/modules/services/misc/ssm-agent.nix

···

       17
       17
        
         '';

     

       18
       18
        
       in {

     

       19
       19
        
         options.services.ssm-agent = {

     

       20
       20
       -
           enable = mkEnableOption "AWS SSM agent";

     

       20
       20
       +
           enable = mkEnableOption (lib.mdDoc "AWS SSM agent");

     

       21
       21
        
       

     

       22
       22
        
           package = mkOption {

     

       23
       23
        
             type = types.path;

+1 -1

nixos/modules/services/misc/sssd.nix

···

       10
       10
        
       in {

     

       11
       11
        
         options = {

     

       12
       12
        
           services.sssd = {

     

       13
       13
       -
             enable = mkEnableOption "the System Security Services Daemon";

     

       13
       13
       +
             enable = mkEnableOption (lib.mdDoc "the System Security Services Daemon");

     

       14
       14
        
       

     

       15
       15
        
             config = mkOption {

     

       16
       16
        
               type = types.lines;

+1 -1

nixos/modules/services/misc/subsonic.nix

···

       8
       8
        
       in {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.subsonic = {

     

       11
       11
       -
             enable = mkEnableOption "Subsonic daemon";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "Subsonic daemon");

     

       12
       12
        
       

     

       13
       13
        
             home = mkOption {

     

       14
       14
        
               type = types.path;

+1 -1

nixos/modules/services/misc/sundtek.nix

···

       8
       8
        
       in

     

       9
       9
        
       {

     

       10
       10
        
         options.services.sundtek = {

     

       11
       11
       -
           enable = mkEnableOption "Sundtek driver";

     

       11
       11
       +
           enable = mkEnableOption (lib.mdDoc "Sundtek driver");

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         config = mkIf cfg.enable {

+2 -2

nixos/modules/services/misc/synergy.nix

···

       19
       19
        
             # !!! All these option descriptions needs to be cleaned up.

     

       20
       20
        
       

     

       21
       21
        
             client = {

     

       22
       22
       -
               enable = mkEnableOption "the Synergy client (receive keyboard and mouse events from a Synergy server)";

     

       22
       22
       +
               enable = mkEnableOption (lib.mdDoc "the Synergy client (receive keyboard and mouse events from a Synergy server)");

     

       23
       23
        
       

     

       24
       24
        
               screenName = mkOption {

     

       25
       25
        
                 default = "";

     
···

       45
       45
        
             };

     

       46
       46
        
       

     

       47
       47
        
             server = {

     

       48
       48
       -
               enable = mkEnableOption "the Synergy server (send keyboard and mouse events)";

     

       48
       48
       +
               enable = mkEnableOption (lib.mdDoc "the Synergy server (send keyboard and mouse events)");

     

       49
       49
        
       

     

       50
       50
        
               configFile = mkOption {

     

       51
       51
        
                 type = types.path;

+1 -1

nixos/modules/services/misc/sysprof.nix

···

       3
       3
        
       {

     

       4
       4
        
         options = {

     

       5
       5
        
           services.sysprof = {

     

       6
       6
       -
             enable = lib.mkEnableOption "sysprof profiling daemon";

     

       6
       6
       +
             enable = lib.mkEnableOption (lib.mdDoc "sysprof profiling daemon");

     

       7
       7
        
           };

     

       8
       8
        
         };

     

       9
       9

+1 -1

nixos/modules/services/misc/tautulli.nix

···

       12
       12
        
       

     

       13
       13
        
         options = {

     

       14
       14
        
           services.tautulli = {

     

       15
       15
       -
             enable = mkEnableOption "Tautulli Plex Monitor";

     

       15
       15
       +
             enable = mkEnableOption (lib.mdDoc "Tautulli Plex Monitor");

     

       16
       16
        
       

     

       17
       17
        
             dataDir = mkOption {

     

       18
       18
        
               type = types.str;

+1 -1

nixos/modules/services/misc/tiddlywiki.nix

···

       14
       14
        
       

     

       15
       15
        
         options.services.tiddlywiki = {

     

       16
       16
        
       

     

       17
       17
       -
           enable = mkEnableOption "TiddlyWiki nodejs server";

     

       17
       17
       +
           enable = mkEnableOption (lib.mdDoc "TiddlyWiki nodejs server");

     

       18
       18
        
       

     

       19
       19
        
           listenOptions = mkOption {

     

       20
       20
        
             type = types.attrs;

+1 -1

nixos/modules/services/misc/tp-auto-kbbl.nix

···

       9
       9
        
       

     

       10
       10
        
         options = {

     

       11
       11
        
           services.tp-auto-kbbl = {

     

       12
       12
       -
             enable = mkEnableOption "Auto toggle keyboard back-lighting on Thinkpads (and maybe other laptops) for Linux";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "Auto toggle keyboard back-lighting on Thinkpads (and maybe other laptops) for Linux");

     

       13
       13
        
       

     

       14
       14
        
             package = mkOption {

     

       15
       15
        
               type = types.package;

+1 -1

nixos/modules/services/misc/uhub.nix

···

       19
       19
        
             type = types.attrsOf (types.submodule {

     

       20
       20
        
               options = {

     

       21
       21
        
       

     

       22
       22
       -
                 enable = mkEnableOption "hub instance" // { default = true; };

     

       22
       22
       +
                 enable = mkEnableOption (lib.mdDoc "hub instance") // { default = true; };

     

       23
       23
        
       

     

       24
       24
        
                 enableTLS = mkOption {

     

       25
       25
        
                   type = types.bool;

+1 -1

nixos/modules/services/misc/weechat.nix

···

       8
       8
        
       

     

       9
       9
        
       {

     

       10
       10
        
         options.services.weechat = {

     

       11
       11
       -
           enable = mkEnableOption "weechat";

     

       11
       11
       +
           enable = mkEnableOption (lib.mdDoc "weechat");

     

       12
       12
        
           root = mkOption {

     

       13
       13
        
             description = lib.mdDoc "Weechat state directory.";

     

       14
       14
        
             type = types.str;

+3 -3

nixos/modules/services/misc/xmr-stak.nix

···

       15
       15
        
       {

     

       16
       16
        
         options = {

     

       17
       17
        
           services.xmr-stak = {

     

       18
       18
       -
             enable = mkEnableOption "xmr-stak miner";

     

       19
       19
       -
             openclSupport = mkEnableOption "support for OpenCL (AMD/ATI graphics cards)";

     

       20
       20
       -
             cudaSupport = mkEnableOption "support for CUDA (NVidia graphics cards)";

     

       18
       18
       +
             enable = mkEnableOption (lib.mdDoc "xmr-stak miner");

     

       19
       19
       +
             openclSupport = mkEnableOption (lib.mdDoc "support for OpenCL (AMD/ATI graphics cards)");

     

       20
       20
       +
             cudaSupport = mkEnableOption (lib.mdDoc "support for CUDA (NVidia graphics cards)");

     

       21
       21
        
       

     

       22
       22
        
             extraArgs = mkOption {

     

       23
       23
        
               type = types.listOf types.str;

+1 -1

nixos/modules/services/misc/xmrig.nix

···

       13
       13
        
       {

     

       14
       14
        
         options = {

     

       15
       15
        
           services.xmrig = {

     

       16
       16
       -
             enable = mkEnableOption "XMRig Mining Software";

     

       16
       16
       +
             enable = mkEnableOption (lib.mdDoc "XMRig Mining Software");

     

       17
       17
        
       

     

       18
       18
        
             package = mkOption {

     

       19
       19
        
               type = types.package;

+1 -1

nixos/modules/services/monitoring/alerta.nix

···

       21
       21
        
       in

     

       22
       22
        
       {

     

       23
       23
        
         options.services.alerta = {

     

       24
       24
       -
           enable = mkEnableOption "alerta";

     

       24
       24
       +
           enable = mkEnableOption (lib.mdDoc "alerta");

     

       25
       25
        
       

     

       26
       26
        
           port = mkOption {

     

       27
       27
        
             type = types.int;

+1 -1

nixos/modules/services/monitoring/collectd.nix

···

       29
       29
        
       

     

       30
       30
        
       in {

     

       31
       31
        
         options.services.collectd = with types; {

     

       32
       32
       -
           enable = mkEnableOption "collectd agent";

     

       32
       32
       +
           enable = mkEnableOption (lib.mdDoc "collectd agent");

     

       33
       33
        
       

     

       34
       34
        
           validateConfig = mkOption {

     

       35
       35
        
             default = true;

+1 -1

nixos/modules/services/monitoring/das_watchdog.nix

···

       12
       12
        
         ###### interface

     

       13
       13
        
       

     

       14
       14
        
         options = {

     

       15
       15
       -
           services.das_watchdog.enable = mkEnableOption "realtime watchdog";

     

       15
       15
       +
           services.das_watchdog.enable = mkEnableOption (lib.mdDoc "realtime watchdog");

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
        
         ###### implementation

+1 -1

nixos/modules/services/monitoring/do-agent.nix

···

       8
       8
        
       in

     

       9
       9
        
       {

     

       10
       10
        
         options.services.do-agent = {

     

       11
       11
       -
           enable = mkEnableOption "do-agent, the DigitalOcean droplet metrics agent";

     

       11
       11
       +
           enable = mkEnableOption (lib.mdDoc "do-agent, the DigitalOcean droplet metrics agent");

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         config = mkIf cfg.enable {

+1 -1

nixos/modules/services/monitoring/fusion-inventory.nix

···

       22
       22
        
       

     

       23
       23
        
           services.fusionInventory = {

     

       24
       24
        
       

     

       25
       25
       -
             enable = mkEnableOption "Fusion Inventory Agent";

     

       25
       25
       +
             enable = mkEnableOption (lib.mdDoc "Fusion Inventory Agent");

     

       26
       26
        
       

     

       27
       27
        
             servers = mkOption {

     

       28
       28
        
               type = types.listOf types.str;

+1 -1

nixos/modules/services/monitoring/grafana-agent.nix

···

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         options.services.grafana-agent = {

     

       14
       14
       -
           enable = mkEnableOption "grafana-agent";

     

       14
       14
       +
           enable = mkEnableOption (lib.mdDoc "grafana-agent");

     

       15
       15
        
       

     

       16
       16
        
           package = mkOption {

     

       17
       17
        
             type = types.package;

+3 -3

nixos/modules/services/monitoring/grafana-image-renderer.nix

···

       10
       10
        
         configFile = format.generate "grafana-image-renderer-config.json" cfg.settings;

     

       11
       11
        
       in {

     

       12
       12
        
         options.services.grafana-image-renderer = {

     

       13
       13
       -
           enable = mkEnableOption "grafana-image-renderer";

     

       13
       13
       +
           enable = mkEnableOption (lib.mdDoc "grafana-image-renderer");

     

       14
       14
        
       

     

       15
       15
        
           chromium = mkOption {

     

       16
       16
        
             type = types.package;

     
···

       19
       19
        
             '';

     

       20
       20
        
           };

     

       21
       21
        
       

     

       22
       22
       -
           verbose = mkEnableOption "verbosity for the service";

     

       22
       22
       +
           verbose = mkEnableOption (lib.mdDoc "verbosity for the service");

     

       23
       23
        
       

     

       24
       24
       -
           provisionGrafana = mkEnableOption "Grafana configuration for grafana-image-renderer";

     

       24
       24
       +
           provisionGrafana = mkEnableOption (lib.mdDoc "Grafana configuration for grafana-image-renderer");

     

       25
       25
        
       

     

       26
       26
        
           settings = mkOption {

     

       27
       27
        
             type = types.submodule {

+1 -1

nixos/modules/services/monitoring/grafana-reporter.nix

···

       7
       7
        
       

     

       8
       8
        
       in {

     

       9
       9
        
         options.services.grafana_reporter = {

     

       10
       10
       -
           enable = mkEnableOption "grafana_reporter";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "grafana_reporter");

     

       11
       11
        
       

     

       12
       12
        
           grafana = {

     

       13
       13
        
             protocol = mkOption {

+3 -3

nixos/modules/services/monitoring/grafana.nix

···

       302
       302
        
         };

     

       303
       303
        
       in {

     

       304
       304
        
         options.services.grafana = {

     

       305
       305
       -
           enable = mkEnableOption "grafana";

     

       305
       305
       +
           enable = mkEnableOption (lib.mdDoc "grafana");

     

       306
       306
        
       

     

       307
       307
        
           protocol = mkOption {

     

       308
       308
        
             description = lib.mdDoc "Which protocol to listen.";

     
···

       445
       445
        
           };

     

       446
       446
        
       

     

       447
       447
        
           provision = {

     

       448
       448
       -
             enable = mkEnableOption "provision";

     

       448
       448
       +
             enable = mkEnableOption (lib.mdDoc "provision");

     

       449
       449
        
             datasources = mkOption {

     

       450
       450
        
               description = lib.mdDoc "Grafana datasources configuration.";

     

       451
       451
        
               default = [];

     
···

       513
       513
        
           };

     

       514
       514
        
       

     

       515
       515
        
           smtp = {

     

       516
       516
       -
             enable = mkEnableOption "smtp";

     

       516
       516
       +
             enable = mkEnableOption (lib.mdDoc "smtp");

     

       517
       517
        
             host = mkOption {

     

       518
       518
        
               description = lib.mdDoc "Host to connect to.";

     

       519
       519
        
               default = "localhost:25";

+2 -2

nixos/modules/services/monitoring/hdaps.nix

···

       9
       9
        
       {

     

       10
       10
        
         options = {

     

       11
       11
        
           services.hdapsd.enable = mkEnableOption

     

       12
       12
       -
             ''

     

       12
       12
       +
             (lib.mdDoc ''

     

       13
       13
        
               Hard Drive Active Protection System Daemon,

     

       14
       14
        
               devices are detected and managed automatically by udev and systemd

     

       15
       15
       -
             '';

     

       15
       15
       +
             '');

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
        
         config = mkIf cfg.enable {

+2 -2

nixos/modules/services/monitoring/incron.nix

···

       17
       17
        
             enable = mkOption {

     

       18
       18
        
               type = types.bool;

     

       19
       19
        
               default = false;

     

       20
       20
       -
               description = ''

     

       20
       20
       +
               description = lib.mdDoc ''

     

       21
       21
        
                 Whether to enable the incron daemon.

     

       22
       22
        
       

     

       23
       23
       -
                 Note that commands run under incrontab only support common Nix profiles for the <envar>PATH</envar> provided variable.

     

       23
       23
       +
                 Note that commands run under incrontab only support common Nix profiles for the {env}`PATH` provided variable.

     

       24
       24
        
               '';

     

       25
       25
        
             };

     

       26
       26

+3 -3

nixos/modules/services/monitoring/kapacitor.nix

···

       57
       57
        
       in

     

       58
       58
        
       {

     

       59
       59
        
         options.services.kapacitor = {

     

       60
       60
       -
           enable = mkEnableOption "kapacitor";

     

       60
       60
       +
           enable = mkEnableOption (lib.mdDoc "kapacitor");

     

       61
       61
        
       

     

       62
       62
        
           dataDir = mkOption {

     

       63
       63
        
             type = types.path;

     
···

       109
       109
        
           };

     

       110
       110
        
       

     

       111
       111
        
           defaultDatabase = {

     

       112
       112
       -
             enable = mkEnableOption "kapacitor.defaultDatabase";

     

       112
       112
       +
             enable = mkEnableOption (lib.mdDoc "kapacitor.defaultDatabase");

     

       113
       113
        
       

     

       114
       114
        
             url = mkOption {

     

       115
       115
        
               description = lib.mdDoc "The URL to an InfluxDB server that serves as the default database";

     
···

       129
       129
        
           };

     

       130
       130
        
       

     

       131
       131
        
           alerta = {

     

       132
       132
       -
             enable = mkEnableOption "kapacitor alerta integration";

     

       132
       132
       +
             enable = mkEnableOption (lib.mdDoc "kapacitor alerta integration");

     

       133
       133
        
       

     

       134
       134
        
             url = mkOption {

     

       135
       135
        
               description = lib.mdDoc "The URL to the Alerta REST API";

+1 -1

nixos/modules/services/monitoring/loki.nix

···

       12
       12
        
       

     

       13
       13
        
       in {

     

       14
       14
        
         options.services.loki = {

     

       15
       15
       -
           enable = mkEnableOption "loki";

     

       15
       15
       +
           enable = mkEnableOption (lib.mdDoc "loki");

     

       16
       16
        
       

     

       17
       17
        
           user = mkOption {

     

       18
       18
        
             type = types.str;

+5 -5

nixos/modules/services/monitoring/mackerel-agent.nix

···

       7
       7
        
         settingsFmt = pkgs.formats.toml {};

     

       8
       8
        
       in {

     

       9
       9
        
         options.services.mackerel-agent = {

     

       10
       10
       -
           enable = mkEnableOption "mackerel.io agent";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "mackerel.io agent");

     

       11
       11
        
       

     

       12
       12
        
           # the upstream package runs as root, but doesn't seem to be strictly

     

       13
       13
        
           # necessary for basic functionality

     

       14
       14
       -
           runAsRoot = mkEnableOption "Whether to run as root.";

     

       14
       14
       +
           runAsRoot = mkEnableOption (lib.mdDoc "Whether to run as root.");

     

       15
       15
        
       

     

       16
       16
       -
           autoRetirement = mkEnableOption ''

     

       16
       16
       +
           autoRetirement = mkEnableOption (lib.mdDoc ''

     

       17
       17
        
             Whether to automatically retire the host upon OS shutdown.

     

       18
       18
       -
           '';

     

       18
       18
       +
           '');

     

       19
       19
        
       

     

       20
       20
        
           apiKeyFile = mkOption {

     

       21
       21
        
             type = types.path;

     
···

       59
       59
        
               };

     

       60
       60
        
       

     

       61
       61
        
               options.diagnostic =

     

       62
       62
       -
                 mkEnableOption "Collect memory usage for the agent itself";

     

       62
       62
       +
                 mkEnableOption (lib.mdDoc "Collect memory usage for the agent itself");

     

       63
       63
        
             };

     

       64
       64
        
           };

     

       65
       65
        
         };

+1 -1

nixos/modules/services/monitoring/metricbeat.nix

···

       19
       19
        
       

     

       20
       20
        
           services.metricbeat = {

     

       21
       21
        
       

     

       22
       22
       -
             enable = mkEnableOption "metricbeat";

     

       22
       22
       +
             enable = mkEnableOption (lib.mdDoc "metricbeat");

     

       23
       23
        
       

     

       24
       24
        
             package = mkOption {

     

       25
       25
        
               type = types.package;

+1 -1

nixos/modules/services/monitoring/mimir.nix

···

       8
       8
        
         settingsFormat = pkgs.formats.yaml {};

     

       9
       9
        
       in {

     

       10
       10
        
         options.services.mimir = {

     

       11
       11
       -
           enable = mkEnableOption "mimir";

     

       11
       11
       +
           enable = mkEnableOption (lib.mdDoc "mimir");

     

       12
       12
        
       

     

       13
       13
        
           configuration = mkOption {

     

       14
       14
        
             type = (pkgs.formats.json {}).type;

+1 -1

nixos/modules/services/monitoring/monit.nix

···

       9
       9
        
       {

     

       10
       10
        
         options.services.monit = {

     

       11
       11
        
       

     

       12
       12
       -
           enable = mkEnableOption "Monit";

     

       12
       12
       +
           enable = mkEnableOption (lib.mdDoc "Monit");

     

       13
       13
        
       

     

       14
       14
        
           config = mkOption {

     

       15
       15
        
             type = types.lines;

+3 -3

nixos/modules/services/monitoring/nagios.nix

···

       88
       88
        
       

     

       89
       89
        
         options = {

     

       90
       90
        
           services.nagios = {

     

       91
       91
       -
             enable = mkEnableOption ''<link xlink:href="http://www.nagios.org/">Nagios</link> to monitor your system or network.'';

     

       91
       91
       +
             enable = mkEnableOption (lib.mdDoc ''[Nagios](http://www.nagios.org/) to monitor your system or network.'');

     

       92
       92
        
       

     

       93
       93
        
             objectDefs = mkOption {

     

       94
       94
        
               description = lib.mdDoc ''

     
···

       104
       104
        
               type = types.listOf types.package;

     

       105
       105
        
               default = with pkgs; [ monitoring-plugins msmtp mailutils ];

     

       106
       106
        
               defaultText = literalExpression "[pkgs.monitoring-plugins pkgs.msmtp pkgs.mailutils]";

     

       107
       107
       -
               description = ''

     

       108
       108
       -
                 Packages to be added to the Nagios <envar>PATH</envar>.

     

       107
       107
       +
               description = lib.mdDoc ''

     

       108
       108
       +
                 Packages to be added to the Nagios {env}`PATH`.

     

       109
       109
        
                 Typically used to add plugins, but can be anything.

     

       110
       110
        
               '';

     

       111
       111
        
             };

+1 -1

nixos/modules/services/monitoring/netdata.nix

···

       49
       49
        
       in {

     

       50
       50
        
         options = {

     

       51
       51
        
           services.netdata = {

     

       52
       52
       -
             enable = mkEnableOption "netdata";

     

       52
       52
       +
             enable = mkEnableOption (lib.mdDoc "netdata");

     

       53
       53
        
       

     

       54
       54
        
             package = mkOption {

     

       55
       55
        
               type = types.package;

+2 -2

nixos/modules/services/monitoring/parsedmarc.nix

···

       20
       20
        
       {

     

       21
       21
        
         options.services.parsedmarc = {

     

       22
       22
        
       

     

       23
       23
       -
           enable = lib.mkEnableOption ''

     

       23
       23
       +
           enable = lib.mkEnableOption (lib.mdDoc ''

     

       24
       24
        
             parsedmarc, a DMARC report monitoring service

     

       25
       25
       -
           '';

     

       25
       25
       +
           '');

     

       26
       26
        
       

     

       27
       27
        
           provision = {

     

       28
       28
        
             localMail = {

+1 -1

nixos/modules/services/monitoring/prometheus/alertmanager.nix

···

       40
       40
        
       

     

       41
       41
        
         options = {

     

       42
       42
        
           services.prometheus.alertmanager = {

     

       43
       43
       -
             enable = mkEnableOption "Prometheus Alertmanager";

     

       43
       43
       +
             enable = mkEnableOption (lib.mdDoc "Prometheus Alertmanager");

     

       44
       44
        
       

     

       45
       45
        
             package = mkOption {

     

       46
       46
        
               type = types.package;

+1 -1

nixos/modules/services/monitoring/prometheus/exporters.nix

···

       80
       80
        
         );

     

       81
       81
        
       

     

       82
       82
        
         mkExporterOpts = ({ name, port }: {

     

       83
       83
       -
           enable = mkEnableOption "the prometheus ${name} exporter";

     

       83
       83
       +
           enable = mkEnableOption (lib.mdDoc "the prometheus ${name} exporter");

     

       84
       84
        
           port = mkOption {

     

       85
       85
        
             type = types.port;

     

       86
       86
        
             default = port;

+1 -1

nixos/modules/services/monitoring/prometheus/exporters/collectd.nix

···

       9
       9
        
         port = 9103;

     

       10
       10
        
         extraOpts = {

     

       11
       11
        
           collectdBinary = {

     

       12
       12
       -
             enable = mkEnableOption "collectd binary protocol receiver";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "collectd binary protocol receiver");

     

       13
       13
        
       

     

       14
       14
        
             authFile = mkOption {

     

       15
       15
        
               default = null;

+1 -1

nixos/modules/services/monitoring/prometheus/exporters/fastly.nix

···

       7
       7
        
       {

     

       8
       8
        
         port = 9118;

     

       9
       9
        
         extraOpts = {

     

       10
       10
       -
           debug = mkEnableOption "Debug logging mode for fastly-exporter";

     

       10
       10
       +
           debug = mkEnableOption (lib.mdDoc "Debug logging mode for fastly-exporter");

     

       11
       11
        
       

     

       12
       12
        
           configFile = mkOption {

     

       13
       13
        
             type = types.nullOr types.path;

+3 -3

nixos/modules/services/monitoring/prometheus/exporters/unifi-poller.nix

···

       21
       21
        
         extraOpts = {

     

       22
       22
        
           inherit (options.services.unifi-poller.unifi) controllers;

     

       23
       23
        
           log = {

     

       24
       24
       -
             debug = mkEnableOption "debug logging including line numbers, high resolution timestamps, per-device logs.";

     

       25
       25
       -
             quiet = mkEnableOption "startup and error logs only.";

     

       26
       26
       -
             prometheusErrors = mkEnableOption "emitting errors to prometheus.";

     

       24
       24
       +
             debug = mkEnableOption (lib.mdDoc "debug logging including line numbers, high resolution timestamps, per-device logs.");

     

       25
       25
       +
             quiet = mkEnableOption (lib.mdDoc "startup and error logs only.");

     

       26
       26
       +
             prometheusErrors = mkEnableOption (lib.mdDoc "emitting errors to prometheus.");

     

       27
       27
        
           };

     

       28
       28
        
         };

     

       29
       29

+1 -1

nixos/modules/services/monitoring/prometheus/exporters/wireguard.nix

···

       11
       11
        
           ({ options.warnings = options.warnings; options.assertions = options.assertions; })

     

       12
       12
        
         ];

     

       13
       13
        
         extraOpts = {

     

       14
       14
       -
           verbose = mkEnableOption "Verbose logging mode for prometheus-wireguard-exporter";

     

       14
       14
       +
           verbose = mkEnableOption (lib.mdDoc "Verbose logging mode for prometheus-wireguard-exporter");

     

       15
       15
        
       

     

       16
       16
        
           wireguardConfig = mkOption {

     

       17
       17
        
             type = with types; nullOr (either path str);

+1 -1

nixos/modules/services/monitoring/prometheus/pushgateway.nix

···

       21
       21
        
       in {

     

       22
       22
        
         options = {

     

       23
       23
        
           services.prometheus.pushgateway = {

     

       24
       24
       -
             enable = mkEnableOption "Prometheus Pushgateway";

     

       24
       24
       +
             enable = mkEnableOption (lib.mdDoc "Prometheus Pushgateway");

     

       25
       25
        
       

     

       26
       26
        
             package = mkOption {

     

       27
       27
        
               type = types.package;

+4 -4

nixos/modules/services/monitoring/prometheus/sachet.nix

···

       9
       9
        
       {

     

       10
       10
        
         options = {

     

       11
       11
        
           services.prometheus.sachet = {

     

       12
       12
       -
             enable = mkEnableOption "Sachet, an SMS alerting tool for the Prometheus Alertmanager";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "Sachet, an SMS alerting tool for the Prometheus Alertmanager");

     

       13
       13
        
       

     

       14
       14
        
             configuration = mkOption {

     

       15
       15
        
               type = types.nullOr types.attrs;

     
···

       32
       32
        
                   }];

     

       33
       33
        
                 }

     

       34
       34
        
               '';

     

       35
       35
       -
               description = ''

     

       35
       35
       +
               description = lib.mdDoc ''

     

       36
       36
        
                 Sachet's configuration as a nix attribute set.

     

       37
       37
        
               '';

     

       38
       38
        
             };

     
···

       40
       40
        
             address = mkOption {

     

       41
       41
        
               type = types.str;

     

       42
       42
        
               default = "localhost";

     

       43
       43
       -
               description = ''

     

       43
       43
       +
               description = lib.mdDoc ''

     

       44
       44
        
                 The address Sachet will listen to.

     

       45
       45
        
               '';

     

       46
       46
        
             };

     
···

       48
       48
        
             port = mkOption {

     

       49
       49
        
               type = types.port;

     

       50
       50
        
               default = 9876;

     

       51
       51
       -
               description = ''

     

       51
       51
       +
               description = lib.mdDoc ''

     

       52
       52
        
                 The port Sachet will listen to.

     

       53
       53
        
               '';

     

       54
       54
        
             };

+1 -1

nixos/modules/services/monitoring/prometheus/xmpp-alerts.nix

···

       15
       15
        
         ];

     

       16
       16
        
       

     

       17
       17
        
         options.services.prometheus.xmpp-alerts = {

     

       18
       18
       -
           enable = mkEnableOption "XMPP Web hook service for Alertmanager";

     

       18
       18
       +
           enable = mkEnableOption (lib.mdDoc "XMPP Web hook service for Alertmanager");

     

       19
       19
        
       

     

       20
       20
        
           settings = mkOption {

     

       21
       21
        
             type = settingsFormat.type;

+1 -1

nixos/modules/services/monitoring/smartd.nix

···

       95
       95
        
       

     

       96
       96
        
           services.smartd = {

     

       97
       97
        
       

     

       98
       98
       -
             enable = mkEnableOption "smartd daemon from <literal>smartmontools</literal> package";

     

       98
       98
       +
             enable = mkEnableOption (lib.mdDoc "smartd daemon from `smartmontools` package");

     

       99
       99
        
       

     

       100
       100
        
             autodetect = mkOption {

     

       101
       101
        
               default = true;

+1 -1

nixos/modules/services/monitoring/statsd.nix

···

       56
       56
        
       

     

       57
       57
        
         options.services.statsd = {

     

       58
       58
        
       

     

       59
       59
       -
           enable = mkEnableOption "statsd";

     

       59
       59
       +
           enable = mkEnableOption (lib.mdDoc "statsd");

     

       60
       60
        
       

     

       61
       61
        
           listenAddress = mkOption {

     

       62
       62
        
             description = lib.mdDoc "Address that statsd listens on over UDP";

+1 -1

nixos/modules/services/monitoring/sysstat.nix

···

       5
       5
        
       in {

     

       6
       6
        
         options = {

     

       7
       7
        
           services.sysstat = {

     

       8
       8
       -
             enable = mkEnableOption "sar system activity collection";

     

       8
       8
       +
             enable = mkEnableOption (lib.mdDoc "sar system activity collection");

     

       9
       9
        
       

     

       10
       10
        
             collect-frequency = mkOption {

     

       11
       11
        
               type = types.str;

+1 -1

nixos/modules/services/monitoring/teamviewer.nix

···

       14
       14
        
       

     

       15
       15
        
         options = {

     

       16
       16
        
       

     

       17
       17
       -
           services.teamviewer.enable = mkEnableOption "TeamViewer daemon";

     

       17
       17
       +
           services.teamviewer.enable = mkEnableOption (lib.mdDoc "TeamViewer daemon");

     

       18
       18
        
       

     

       19
       19
        
         };

     

       20
       20

+1 -1

nixos/modules/services/monitoring/telegraf.nix

···

       11
       11
        
         ###### interface

     

       12
       12
        
         options = {

     

       13
       13
        
           services.telegraf = {

     

       14
       14
       -
             enable = mkEnableOption "telegraf server";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "telegraf server");

     

       15
       15
        
       

     

       16
       16
        
             package = mkOption {

     

       17
       17
        
               default = pkgs.telegraf;

+10 -10

nixos/modules/services/monitoring/thanos.nix

···

       667
       667
        
       

     

       668
       668
        
           sidecar = paramsToOptions params.sidecar // {

     

       669
       669
        
             enable = mkEnableOption

     

       670
       670
       -
               "the Thanos sidecar for Prometheus server";

     

       670
       670
       +
               (lib.mdDoc "the Thanos sidecar for Prometheus server");

     

       671
       671
        
             arguments = mkArgumentsOption "sidecar";

     

       672
       672
        
           };

     

       673
       673
        
       

     

       674
       674
        
           store = paramsToOptions params.store // {

     

       675
       675
        
             enable = mkEnableOption

     

       676
       676
       -
               "the Thanos store node giving access to blocks in a bucket provider.";

     

       676
       676
       +
               (lib.mdDoc "the Thanos store node giving access to blocks in a bucket provider.");

     

       677
       677
        
             arguments = mkArgumentsOption "store";

     

       678
       678
        
           };

     

       679
       679
        
       

     

       680
       680
        
           query = paramsToOptions params.query // {

     

       681
       681
        
             enable = mkEnableOption

     

       682
       682
       -
               ("the Thanos query node exposing PromQL enabled Query API " +

     

       683
       683
       -
                "with data retrieved from multiple store nodes");

     

       682
       682
       +
               (lib.mdDoc ("the Thanos query node exposing PromQL enabled Query API " +

     

       683
       683
       +
                "with data retrieved from multiple store nodes"));

     

       684
       684
        
             arguments = mkArgumentsOption "query";

     

       685
       685
        
           };

     

       686
       686
        
       

     

       687
       687
        
           rule = paramsToOptions params.rule // {

     

       688
       688
        
             enable = mkEnableOption

     

       689
       689
       -
               ("the Thanos ruler service which evaluates Prometheus rules against" +

     

       690
       690
       -
               " given Query nodes, exposing Store API and storing old blocks in bucket");

     

       689
       689
       +
               (lib.mdDoc ("the Thanos ruler service which evaluates Prometheus rules against" +

     

       690
       690
       +
               " given Query nodes, exposing Store API and storing old blocks in bucket"));

     

       691
       691
        
             arguments = mkArgumentsOption "rule";

     

       692
       692
        
           };

     

       693
       693
        
       

     

       694
       694
        
           compact = paramsToOptions params.compact // {

     

       695
       695
        
             enable = mkEnableOption

     

       696
       696
       -
               "the Thanos compactor which continuously compacts blocks in an object store bucket";

     

       696
       696
       +
               (lib.mdDoc "the Thanos compactor which continuously compacts blocks in an object store bucket");

     

       697
       697
        
             arguments = mkArgumentsOption "compact";

     

       698
       698
        
           };

     

       699
       699
        
       

     

       700
       700
        
           downsample = paramsToOptions params.downsample // {

     

       701
       701
        
             enable = mkEnableOption

     

       702
       702
       -
               "the Thanos downsampler which continuously downsamples blocks in an object store bucket";

     

       702
       702
       +
               (lib.mdDoc "the Thanos downsampler which continuously downsamples blocks in an object store bucket");

     

       703
       703
        
             arguments = mkArgumentsOption "downsample";

     

       704
       704
        
           };

     

       705
       705
        
       

     

       706
       706
        
           receive = paramsToOptions params.receive // {

     

       707
       707
        
             enable = mkEnableOption

     

       708
       708
       -
               ("the Thanos receiver which accept Prometheus remote write API requests " +

     

       709
       709
       -
                "and write to local tsdb (EXPERIMENTAL, this may change drastically without notice)");

     

       708
       708
       +
               (lib.mdDoc ("the Thanos receiver which accept Prometheus remote write API requests " +

     

       709
       709
       +
                "and write to local tsdb (EXPERIMENTAL, this may change drastically without notice)"));

     

       710
       710
        
             arguments = mkArgumentsOption "receive";

     

       711
       711
        
           };

     

       712
       712
        
         };

+1 -1

nixos/modules/services/monitoring/tuptime.nix

···

       10
       10
        
       

     

       11
       11
        
         options.services.tuptime = {

     

       12
       12
        
       

     

       13
       13
       -
           enable = mkEnableOption "the total uptime service";

     

       13
       13
       +
           enable = mkEnableOption (lib.mdDoc "the total uptime service");

     

       14
       14
        
       

     

       15
       15
        
           timer = {

     

       16
       16
        
             enable = mkOption {

+1 -1

nixos/modules/services/monitoring/unifi-poller.nix

···

       11
       11
        
       

     

       12
       12
        
       in {

     

       13
       13
        
         options.services.unifi-poller = {

     

       14
       14
       -
           enable = mkEnableOption "unifi-poller";

     

       14
       14
       +
           enable = mkEnableOption (lib.mdDoc "unifi-poller");

     

       15
       15
        
       

     

       16
       16
        
           poller = {

     

       17
       17
        
             debug = mkOption {

+2 -2

nixos/modules/services/monitoring/uptime.nix

···

       51
       51
        
             type = types.bool;

     

       52
       52
        
           };

     

       53
       53
        
       

     

       54
       54
       -
           enableWebService = mkEnableOption "the uptime monitoring program web service";

     

       54
       54
       +
           enableWebService = mkEnableOption (lib.mdDoc "the uptime monitoring program web service");

     

       55
       55
        
       

     

       56
       56
       -
           enableSeparateMonitoringService = mkEnableOption "the uptime monitoring service" // {

     

       56
       56
       +
           enableSeparateMonitoringService = mkEnableOption (lib.mdDoc "the uptime monitoring service") // {

     

       57
       57
        
             default = cfg.enableWebService;

     

       58
       58
        
             defaultText = literalExpression "config.${opt.enableWebService}";

     

       59
       59
        
           };

+1 -1

nixos/modules/services/monitoring/vnstat.nix

···

       6
       6
        
         cfg = config.services.vnstat;

     

       7
       7
        
       in {

     

       8
       8
        
         options.services.vnstat = {

     

       9
       9
       -
           enable = mkEnableOption "update of network usage statistics via vnstatd";

     

       9
       9
       +
           enable = mkEnableOption (lib.mdDoc "update of network usage statistics via vnstatd");

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         config = mkIf cfg.enable {

+3 -3

nixos/modules/services/monitoring/zabbix-agent.nix

···

       29
       29
        
         options = {

     

       30
       30
        
       

     

       31
       31
        
           services.zabbixAgent = {

     

       32
       32
       -
             enable = mkEnableOption "the Zabbix Agent";

     

       32
       32
       +
             enable = mkEnableOption (lib.mdDoc "the Zabbix Agent");

     

       33
       33
        
       

     

       34
       34
        
             package = mkOption {

     

       35
       35
        
               type = types.package;

     
···

       43
       43
        
               default = with pkgs; [ nettools ];

     

       44
       44
        
               defaultText = literalExpression "with pkgs; [ nettools ]";

     

       45
       45
        
               example = literalExpression "with pkgs; [ nettools mysql ]";

     

       46
       46
       -
               description = ''

     

       47
       47
       -
                 Packages to be added to the Zabbix <envar>PATH</envar>.

     

       46
       46
       +
               description = lib.mdDoc ''

     

       47
       47
       +
                 Packages to be added to the Zabbix {env}`PATH`.

     

       48
       48
        
                 Typically used to add executables for scripts, but can be anything.

     

       49
       49
        
               '';

     

       50
       50
        
             };

+3 -3

nixos/modules/services/monitoring/zabbix-proxy.nix

···

       38
       38
        
         options = {

     

       39
       39
        
       

     

       40
       40
        
           services.zabbixProxy = {

     

       41
       41
       -
             enable = mkEnableOption "the Zabbix Proxy";

     

       41
       41
       +
             enable = mkEnableOption (lib.mdDoc "the Zabbix Proxy");

     

       42
       42
        
       

     

       43
       43
        
             server = mkOption {

     

       44
       44
        
               type = types.str;

     
···

       61
       61
        
               type = types.listOf types.package;

     

       62
       62
        
               default = with pkgs; [ nettools nmap traceroute ];

     

       63
       63
        
               defaultText = literalExpression "[ nettools nmap traceroute ]";

     

       64
       64
       -
               description = ''

     

       65
       65
       -
                 Packages to be added to the Zabbix <envar>PATH</envar>.

     

       64
       64
       +
               description = lib.mdDoc ''

     

       65
       65
       +
                 Packages to be added to the Zabbix {env}`PATH`.

     

       66
       66
        
                 Typically used to add executables for scripts, but can be anything.

     

       67
       67
        
               '';

     

       68
       68
        
             };

+3 -3

nixos/modules/services/monitoring/zabbix-server.nix

···

       40
       40
        
         options = {

     

       41
       41
        
       

     

       42
       42
        
           services.zabbixServer = {

     

       43
       43
       -
             enable = mkEnableOption "the Zabbix Server";

     

       43
       43
       +
             enable = mkEnableOption (lib.mdDoc "the Zabbix Server");

     

       44
       44
        
       

     

       45
       45
        
             package = mkOption {

     

       46
       46
        
               type = types.package;

     
···

       53
       53
        
               type = types.listOf types.package;

     

       54
       54
        
               default = with pkgs; [ nettools nmap traceroute ];

     

       55
       55
        
               defaultText = literalExpression "[ nettools nmap traceroute ]";

     

       56
       56
       -
               description = ''

     

       57
       57
       -
                 Packages to be added to the Zabbix <envar>PATH</envar>.

     

       56
       56
       +
               description = lib.mdDoc ''

     

       57
       57
       +
                 Packages to be added to the Zabbix {env}`PATH`.

     

       58
       58
        
                 Typically used to add executables for scripts, but can be anything.

     

       59
       59
        
               '';

     

       60
       60
        
             };

+7 -7

nixos/modules/services/network-filesystems/ceph.nix

···

       72
       72
        
         options.services.ceph = {

     

       73
       73
        
           # Ceph has a monolithic configuration file but different sections for

     

       74
       74
        
           # each daemon, a separate client section and a global section

     

       75
       75
       -
           enable = mkEnableOption "Ceph global configuration";

     

       75
       75
       +
           enable = mkEnableOption (lib.mdDoc "Ceph global configuration");

     

       76
       76
        
       

     

       77
       77
        
           global = {

     

       78
       78
        
             fsid = mkOption {

     
···

       201
       201
        
           };

     

       202
       202
        
       

     

       203
       203
        
           mgr = {

     

       204
       204
       -
             enable = mkEnableOption "Ceph MGR daemon";

     

       204
       204
       +
             enable = mkEnableOption (lib.mdDoc "Ceph MGR daemon");

     

       205
       205
        
             daemons = mkOption {

     

       206
       206
        
               type = with types; listOf str;

     

       207
       207
        
               default = [];

     
···

       221
       221
        
           };

     

       222
       222
        
       

     

       223
       223
        
           mon = {

     

       224
       224
       -
             enable = mkEnableOption "Ceph MON daemon";

     

       224
       224
       +
             enable = mkEnableOption (lib.mdDoc "Ceph MON daemon");

     

       225
       225
        
             daemons = mkOption {

     

       226
       226
        
               type = with types; listOf str;

     

       227
       227
        
               default = [];

     
···

       241
       241
        
           };

     

       242
       242
        
       

     

       243
       243
        
           osd = {

     

       244
       244
       -
             enable = mkEnableOption "Ceph OSD daemon";

     

       244
       244
       +
             enable = mkEnableOption (lib.mdDoc "Ceph OSD daemon");

     

       245
       245
        
             daemons = mkOption {

     

       246
       246
        
               type = with types; listOf str;

     

       247
       247
        
               default = [];

     
···

       269
       269
        
           };

     

       270
       270
        
       

     

       271
       271
        
           mds = {

     

       272
       272
       -
             enable = mkEnableOption "Ceph MDS daemon";

     

       272
       272
       +
             enable = mkEnableOption (lib.mdDoc "Ceph MDS daemon");

     

       273
       273
        
             daemons = mkOption {

     

       274
       274
        
               type = with types; listOf str;

     

       275
       275
        
               default = [];

     
···

       289
       289
        
           };

     

       290
       290
        
       

     

       291
       291
        
           rgw = {

     

       292
       292
       -
             enable = mkEnableOption "Ceph RadosGW daemon";

     

       292
       292
       +
             enable = mkEnableOption (lib.mdDoc "Ceph RadosGW daemon");

     

       293
       293
        
             daemons = mkOption {

     

       294
       294
        
               type = with types; listOf str;

     

       295
       295
        
               default = [];

     
···

       304
       304
        
           };

     

       305
       305
        
       

     

       306
       306
        
           client = {

     

       307
       307
       -
             enable = mkEnableOption "Ceph client configuration";

     

       307
       307
       +
             enable = mkEnableOption (lib.mdDoc "Ceph client configuration");

     

       308
       308
        
             extraConfig = mkOption {

     

       309
       309
        
               type = with types; attrsOf (attrsOf str);

     

       310
       310
        
               default = {};

+1 -1

nixos/modules/services/network-filesystems/glusterfs.nix

···

       33
       33
        
       

     

       34
       34
        
           services.glusterfs = {

     

       35
       35
        
       

     

       36
       36
       -
             enable = mkEnableOption "GlusterFS Daemon";

     

       36
       36
       +
             enable = mkEnableOption (lib.mdDoc "GlusterFS Daemon");

     

       37
       37
        
       

     

       38
       38
        
             logLevel = mkOption {

     

       39
       39
        
               type = types.enum ["DEBUG" "INFO" "WARNING" "ERROR" "CRITICAL" "TRACE" "NONE"];

+1 -1

nixos/modules/services/network-filesystems/ipfs.nix

···

       52
       52
        
       

     

       53
       53
        
           services.ipfs = {

     

       54
       54
        
       

     

       55
       55
       -
             enable = mkEnableOption "Interplanetary File System (WARNING: may cause severe network degredation)";

     

       55
       55
       +
             enable = mkEnableOption (lib.mdDoc "Interplanetary File System (WARNING: may cause severe network degredation)");

     

       56
       56
        
       

     

       57
       57
        
             package = mkOption {

     

       58
       58
        
               type = types.package;

+1 -1

nixos/modules/services/network-filesystems/litestream/default.nix

···

       8
       8
        
       in

     

       9
       9
        
       {

     

       10
       10
        
         options.services.litestream = {

     

       11
       11
       -
           enable = mkEnableOption "litestream";

     

       11
       11
       +
           enable = mkEnableOption (lib.mdDoc "litestream");

     

       12
       12
        
       

     

       13
       13
        
           package = mkOption {

     

       14
       14
        
             description = lib.mdDoc "Package to use.";

+3 -3

nixos/modules/services/network-filesystems/moosefs.nix

···

       85
       85
        
               description = lib.mdDoc "Run daemons as user moosefs instead of root.";

     

       86
       86
        
             };

     

       87
       87
        
       

     

       88
       88
       -
             client.enable = mkEnableOption "Moosefs client.";

     

       88
       88
       +
             client.enable = mkEnableOption (lib.mdDoc "Moosefs client.");

     

       89
       89
        
       

     

       90
       90
        
             master = {

     

       91
       91
        
               enable = mkOption {

     
···

       131
       131
        
             };

     

       132
       132
        
       

     

       133
       133
        
             metalogger = {

     

       134
       134
       -
               enable = mkEnableOption "Moosefs metalogger daemon.";

     

       134
       134
       +
               enable = mkEnableOption (lib.mdDoc "Moosefs metalogger daemon.");

     

       135
       135
        
       

     

       136
       136
        
               settings = mkOption {

     

       137
       137
        
                 type = types.submodule {

     
···

       149
       149
        
             };

     

       150
       150
        
       

     

       151
       151
        
             chunkserver = {

     

       152
       152
       -
               enable = mkEnableOption "Moosefs chunkserver daemon.";

     

       152
       152
       +
               enable = mkEnableOption (lib.mdDoc "Moosefs chunkserver daemon.");

     

       153
       153
        
       

     

       154
       154
        
               openFirewall = mkOption {

     

       155
       155
        
                 type = types.bool;

+1 -1

nixos/modules/services/network-filesystems/netatalk.nix

···

       10
       10
        
         options = {

     

       11
       11
        
           services.netatalk = {

     

       12
       12
        
       

     

       13
       13
       -
             enable = mkEnableOption "the Netatalk AFP fileserver";

     

       13
       13
       +
             enable = mkEnableOption (lib.mdDoc "the Netatalk AFP fileserver");

     

       14
       14
        
       

     

       15
       15
        
             port = mkOption {

     

       16
       16
        
               type = types.port;

+1 -1

nixos/modules/services/network-filesystems/orangefs/client.nix

···

       10
       10
        
       

     

       11
       11
        
         options = {

     

       12
       12
        
           services.orangefs.client = {

     

       13
       13
       -
             enable = mkEnableOption "OrangeFS client daemon";

     

       13
       13
       +
             enable = mkEnableOption (lib.mdDoc "OrangeFS client daemon");

     

       14
       14
        
       

     

       15
       15
        
             extraOptions = mkOption {

     

       16
       16
        
               type = with types; listOf str;

+1 -1

nixos/modules/services/network-filesystems/orangefs/server.nix

···

       74
       74
        
       

     

       75
       75
        
         options = {

     

       76
       76
        
           services.orangefs.server = {

     

       77
       77
       -
             enable = mkEnableOption "OrangeFS server";

     

       77
       77
       +
             enable = mkEnableOption (lib.mdDoc "OrangeFS server");

     

       78
       78
        
       

     

       79
       79
        
             logType = mkOption {

     

       80
       80
        
               type = with types; enum [ "file" "syslog" ];

+1 -1

nixos/modules/services/network-filesystems/rsyncd.nix

···

       10
       10
        
         options = {

     

       11
       11
        
           services.rsyncd = {

     

       12
       12
        
       

     

       13
       13
       -
             enable = mkEnableOption "the rsync daemon";

     

       13
       13
       +
             enable = mkEnableOption (lib.mdDoc "the rsync daemon");

     

       14
       14
        
       

     

       15
       15
        
             port = mkOption {

     

       16
       16
        
               default = 873;

+3 -3

nixos/modules/services/network-filesystems/tahoe.nix

···

       128
       128
        
                       The number of shares required to store a file.

     

       129
       129
        
                     '';

     

       130
       130
        
                   };

     

       131
       131
       -
                   storage.enable = mkEnableOption "storage service";

     

       131
       131
       +
                   storage.enable = mkEnableOption (lib.mdDoc "storage service");

     

       132
       132
        
                   storage.reservedSpace = mkOption {

     

       133
       133
        
                     default = "1G";

     

       134
       134
        
                     type = types.str;

     
···

       136
       136
        
                       The amount of filesystem space to not use for storage.

     

       137
       137
        
                     '';

     

       138
       138
        
                   };

     

       139
       139
       -
                   helper.enable = mkEnableOption "helper service";

     

       140
       140
       -
                   sftpd.enable = mkEnableOption "SFTP service";

     

       139
       139
       +
                   helper.enable = mkEnableOption (lib.mdDoc "helper service");

     

       140
       140
       +
                   sftpd.enable = mkEnableOption (lib.mdDoc "SFTP service");

     

       141
       141
        
                   sftpd.port = mkOption {

     

       142
       142
        
                     default = null;

     

       143
       143
        
                     type = types.nullOr types.int;

+1 -1

nixos/modules/services/network-filesystems/webdav-server-rs.nix

···

       14
       14
        
       {

     

       15
       15
        
         options = {

     

       16
       16
        
           services.webdav-server-rs = {

     

       17
       17
       -
             enable = mkEnableOption "WebDAV server";

     

       17
       17
       +
             enable = mkEnableOption (lib.mdDoc "WebDAV server");

     

       18
       18
        
       

     

       19
       19
        
             user = mkOption {

     

       20
       20
        
               type = types.str;

+1 -1

nixos/modules/services/network-filesystems/webdav.nix

···

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.webdav = {

     

       11
       11
       -
             enable = mkEnableOption "WebDAV server";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "WebDAV server");

     

       12
       12
        
       

     

       13
       13
        
             user = mkOption {

     

       14
       14
        
               type = types.str;

+3 -3

nixos/modules/services/network-filesystems/xtreemfs.nix

···

       89
       89
        
       

     

       90
       90
        
           services.xtreemfs = {

     

       91
       91
        
       

     

       92
       92
       -
             enable = mkEnableOption "XtreemFS";

     

       92
       92
       +
             enable = mkEnableOption (lib.mdDoc "XtreemFS");

     

       93
       93
        
       

     

       94
       94
        
             homeDir = mkOption {

     

       95
       95
        
               type = types.path;

     
···

       180
       180
        
                 '';

     

       181
       181
        
               };

     

       182
       182
        
               replication = {

     

       183
       183
       -
                 enable = mkEnableOption "XtreemFS DIR replication plugin";

     

       183
       183
       +
                 enable = mkEnableOption (lib.mdDoc "XtreemFS DIR replication plugin");

     

       184
       184
        
                 extraConfig = mkOption {

     

       185
       185
        
                   type = types.lines;

     

       186
       186
        
                   example = ''

     
···

       323
       323
        
                 '';

     

       324
       324
        
               };

     

       325
       325
        
               replication = {

     

       326
       326
       -
                 enable = mkEnableOption "XtreemFS MRC replication plugin";

     

       326
       326
       +
                 enable = mkEnableOption (lib.mdDoc "XtreemFS MRC replication plugin");

     

       327
       327
        
                 extraConfig = mkOption {

     

       328
       328
        
                   type = types.lines;

     

       329
       329
        
                   example = ''

+1 -1

nixos/modules/services/networking/3proxy.nix

···

       6
       6
        
         optionalList = list: if list == [ ] then "*" else concatMapStringsSep "," toString list;

     

       7
       7
        
       in {

     

       8
       8
        
         options.services._3proxy = {

     

       9
       9
       -
           enable = mkEnableOption "3proxy";

     

       9
       9
       +
           enable = mkEnableOption (lib.mdDoc "3proxy");

     

       10
       10
        
           confFile = mkOption {

     

       11
       11
        
             type = types.path;

     

       12
       12
        
             example = "/var/lib/3proxy/3proxy.conf";

+1 -1

nixos/modules/services/networking/adguardhome.nix

···

       25
       25
        
       

     

       26
       26
        
       in {

     

       27
       27
        
         options.services.adguardhome = with types; {

     

       28
       28
       -
           enable = mkEnableOption "AdGuard Home network-wide ad blocker";

     

       28
       28
       +
           enable = mkEnableOption (lib.mdDoc "AdGuard Home network-wide ad blocker");

     

       29
       29
        
       

     

       30
       30
        
           host = mkOption {

     

       31
       31
        
             default = "0.0.0.0";

+1 -1

nixos/modules/services/networking/antennas.nix

···

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.antennas = {

     

       11
       11
       -
             enable = mkEnableOption "Antennas";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "Antennas");

     

       12
       12
        
       

     

       13
       13
        
             tvheadendUrl = mkOption {

     

       14
       14
        
               type        = types.str;

+1 -1

nixos/modules/services/networking/babeld.nix

···

       40
       40
        
       

     

       41
       41
        
           services.babeld = {

     

       42
       42
        
       

     

       43
       43
       -
             enable = mkEnableOption "the babeld network routing daemon";

     

       43
       43
       +
             enable = mkEnableOption (lib.mdDoc "the babeld network routing daemon");

     

       44
       44
        
       

     

       45
       45
        
             interfaceDefaults = mkOption {

     

       46
       46
        
               default = null;

+1 -1

nixos/modules/services/networking/bee-clef.nix

···

       14
       14
        
       

     

       15
       15
        
         options = {

     

       16
       16
        
           services.bee-clef = {

     

       17
       17
       -
             enable = mkEnableOption "clef external signer instance for Ethereum Swarm Bee";

     

       17
       17
       +
             enable = mkEnableOption (lib.mdDoc "clef external signer instance for Ethereum Swarm Bee");

     

       18
       18
        
       

     

       19
       19
        
             dataDir = mkOption {

     

       20
       20
        
               type = types.nullOr types.str;

+1 -1

nixos/modules/services/networking/bee.nix

···

       15
       15
        
       

     

       16
       16
        
         options = {

     

       17
       17
        
           services.bee = {

     

       18
       18
       -
             enable = mkEnableOption "Ethereum Swarm Bee";

     

       18
       18
       +
             enable = mkEnableOption (lib.mdDoc "Ethereum Swarm Bee");

     

       19
       19
        
       

     

       20
       20
        
             package = mkOption {

     

       21
       21
        
               type = types.package;

+2 -2

nixos/modules/services/networking/biboumi.nix

···

       16
       16
        
       {

     

       17
       17
        
         options = {

     

       18
       18
        
           services.biboumi = {

     

       19
       19
       -
             enable = mkEnableOption "the Biboumi XMPP gateway to IRC";

     

       19
       19
       +
             enable = mkEnableOption (lib.mdDoc "the Biboumi XMPP gateway to IRC");

     

       20
       20
        
       

     

       21
       21
        
             settings = mkOption {

     

       22
       22
        
               description = lib.mdDoc ''

     
···

       166
       166
        
               example = "/run/keys/biboumi.cfg";

     

       167
       167
        
             };

     

       168
       168
        
       

     

       169
       169
       -
             openFirewall = mkEnableOption "opening of the identd port in the firewall";

     

       169
       169
       +
             openFirewall = mkEnableOption (lib.mdDoc "opening of the identd port in the firewall");

     

       170
       170
        
           };

     

       171
       171
        
         };

     

       172
       172

+1 -1

nixos/modules/services/networking/bind.nix

···

       104
       104
        
       

     

       105
       105
        
           services.bind = {

     

       106
       106
        
       

     

       107
       107
       -
             enable = mkEnableOption "BIND domain name server";

     

       107
       107
       +
             enable = mkEnableOption (lib.mdDoc "BIND domain name server");

     

       108
       108
        
       

     

       109
       109
        
       

     

       110
       110
        
             package = mkOption {

+2 -2

nixos/modules/services/networking/bird-lg.nix

···

       28
       28
        
             };

     

       29
       29
        
       

     

       30
       30
        
             frontend = {

     

       31
       31
       -
               enable = mkEnableOption "Bird Looking Glass Frontend Webserver";

     

       31
       31
       +
               enable = mkEnableOption (lib.mdDoc "Bird Looking Glass Frontend Webserver");

     

       32
       32
        
       

     

       33
       33
        
               listenAddress = mkOption {

     

       34
       34
        
                 type = types.str;

     
···

       143
       143
        
             };

     

       144
       144
        
       

     

       145
       145
        
             proxy = {

     

       146
       146
       -
               enable = mkEnableOption "Bird Looking Glass Proxy";

     

       146
       146
       +
               enable = mkEnableOption (lib.mdDoc "Bird Looking Glass Proxy");

     

       147
       147
        
       

     

       148
       148
        
               listenAddress = mkOption {

     

       149
       149
        
                 type = types.str;

+1 -1

nixos/modules/services/networking/bird.nix

···

       10
       10
        
         ###### interface

     

       11
       11
        
         options = {

     

       12
       12
        
           services.bird2 = {

     

       13
       13
       -
             enable = mkEnableOption "BIRD Internet Routing Daemon";

     

       13
       13
       +
             enable = mkEnableOption (lib.mdDoc "BIRD Internet Routing Daemon");

     

       14
       14
        
             config = mkOption {

     

       15
       15
        
               type = types.lines;

     

       16
       16
        
               description = lib.mdDoc ''

+4 -4

nixos/modules/services/networking/bitcoind.nix

···

       18
       18
        
             passwordHMAC = mkOption {

     

       19
       19
        
               type = types.uniq (types.strMatching "[0-9a-f]+\\$[0-9a-f]{64}");

     

       20
       20
        
               example = "f7efda5c189b999524f151318c0c86$d5b51b3beffbc02b724e5d095828e0bc8b2456e9ac8757ae3211a5d9b16a22ae";

     

       21
       21
       -
               description = ''

     

       21
       21
       +
               description = lib.mdDoc ''

     

       22
       22
        
                 Password HMAC-SHA-256 for JSON-RPC connections. Must be a string of the

     

       23
       23
       -
                 format &lt;SALT-HEX&gt;$&lt;HMAC-HEX&gt;.

     

       23
       23
       +
                 format \<SALT-HEX\>$\<HMAC-HEX\>.

     

       24
       24
        
       

     

       25
       25
        
                 Tool (Python script) for HMAC generation is available here:

     

       26
       26
       -
                 <link xlink:href="https://github.com/bitcoin/bitcoin/blob/master/share/rpcauth/rpcauth.py"/>

     

       26
       26
       +
                 <https://github.com/bitcoin/bitcoin/blob/master/share/rpcauth/rpcauth.py>

     

       27
       27
        
               '';

     

       28
       28
        
             };

     

       29
       29
        
           };

     
···

       35
       35
        
         bitcoindOpts = { config, lib, name, ...}: {

     

       36
       36
        
           options = {

     

       37
       37
        
       

     

       38
       38
       -
             enable = mkEnableOption "Bitcoin daemon";

     

       38
       38
       +
             enable = mkEnableOption (lib.mdDoc "Bitcoin daemon");

     

       39
       39
        
       

     

       40
       40
        
             package = mkOption {

     

       41
       41
        
               type = types.package;

+1 -1

nixos/modules/services/networking/blockbook-frontend.nix

···

       10
       10
        
       

     

       11
       11
        
           options = {

     

       12
       12
        
       

     

       13
       13
       -
             enable = mkEnableOption "blockbook-frontend application.";

     

       13
       13
       +
             enable = mkEnableOption (lib.mdDoc "blockbook-frontend application.");

     

       14
       14
        
       

     

       15
       15
        
             package = mkOption {

     

       16
       16
        
               type = types.package;

+1 -1

nixos/modules/services/networking/blocky.nix

···

       10
       10
        
       in

     

       11
       11
        
       {

     

       12
       12
        
         options.services.blocky = {

     

       13
       13
       -
           enable = mkEnableOption "Fast and lightweight DNS proxy as ad-blocker for local network with many features";

     

       13
       13
       +
           enable = mkEnableOption (lib.mdDoc "Fast and lightweight DNS proxy as ad-blocker for local network with many features");

     

       14
       14
        
       

     

       15
       15
        
           settings = mkOption {

     

       16
       16
        
             type = format.type;

+1 -1

nixos/modules/services/networking/charybdis.nix

···

       18
       18
        
       

     

       19
       19
        
           services.charybdis = {

     

       20
       20
        
       

     

       21
       21
       -
             enable = mkEnableOption "Charybdis IRC daemon";

     

       21
       21
       +
             enable = mkEnableOption (lib.mdDoc "Charybdis IRC daemon");

     

       22
       22
        
       

     

       23
       23
        
             config = mkOption {

     

       24
       24
        
               type = types.str;

+1 -1

nixos/modules/services/networking/cloudflare-dyndns.nix

···

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.cloudflare-dyndns = {

     

       11
       11
       -
             enable = mkEnableOption "Cloudflare Dynamic DNS Client";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "Cloudflare Dynamic DNS Client");

     

       12
       12
        
       

     

       13
       13
        
             apiTokenFile = mkOption {

     

       14
       14
        
               type = types.nullOr types.str;

+1 -1

nixos/modules/services/networking/cntlm.nix

···

       33
       33
        
       

     

       34
       34
        
         options.services.cntlm = {

     

       35
       35
        
       

     

       36
       36
       -
           enable = mkEnableOption "cntlm, which starts a local proxy";

     

       36
       36
       +
           enable = mkEnableOption (lib.mdDoc "cntlm, which starts a local proxy");

     

       37
       37
        
       

     

       38
       38
        
           username = mkOption {

     

       39
       39
        
             type = types.str;

+1 -1

nixos/modules/services/networking/consul.nix

···

       126
       126
        
             };

     

       127
       127
        
       

     

       128
       128
        
             alerts = {

     

       129
       129
       -
               enable = mkEnableOption "consul-alerts";

     

       129
       129
       +
               enable = mkEnableOption (lib.mdDoc "consul-alerts");

     

       130
       130
        
       

     

       131
       131
        
               package = mkOption {

     

       132
       132
        
                 description = lib.mdDoc "Package to use for consul-alerts.";

+1 -1

nixos/modules/services/networking/coredns.nix

···

       7
       7
        
         configFile = pkgs.writeText "Corefile" cfg.config;

     

       8
       8
        
       in {

     

       9
       9
        
         options.services.coredns = {

     

       10
       10
       -
           enable = mkEnableOption "Coredns dns server";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "Coredns dns server");

     

       11
       11
        
       

     

       12
       12
        
           config = mkOption {

     

       13
       13
        
             default = "";

+1 -1

nixos/modules/services/networking/corerad.nix

···

       10
       10
        
         meta.maintainers = with maintainers; [ mdlayher ];

     

       11
       11
        
       

     

       12
       12
        
         options.services.corerad = {

     

       13
       13
       -
           enable = mkEnableOption "CoreRAD IPv6 NDP RA daemon";

     

       13
       13
       +
           enable = mkEnableOption (lib.mdDoc "CoreRAD IPv6 NDP RA daemon");

     

       14
       14
        
       

     

       15
       15
        
           settings = mkOption {

     

       16
       16
        
             type = settingsFormat.type;

+1 -1

nixos/modules/services/networking/coturn.nix

···

       40
       40
        
       in {

     

       41
       41
        
         options = {

     

       42
       42
        
           services.coturn = {

     

       43
       43
       -
             enable = mkEnableOption "coturn TURN server";

     

       43
       43
       +
             enable = mkEnableOption (lib.mdDoc "coturn TURN server");

     

       44
       44
        
             listening-port = mkOption {

     

       45
       45
        
               type = types.int;

     

       46
       46
        
               default = 3478;

+1 -1

nixos/modules/services/networking/create_ap.nix

···

       8
       8
        
       in {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.create_ap = {

     

       11
       11
       -
             enable = mkEnableOption "setup wifi hotspots using create_ap";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "setup wifi hotspots using create_ap");

     

       12
       12
        
             settings = mkOption {

     

       13
       13
        
               type = with types; attrsOf (oneOf [ int bool str ]);

     

       14
       14
        
               default = {};

+3 -3

nixos/modules/services/networking/croc.nix

···

       6
       6
        
       in

     

       7
       7
        
       {

     

       8
       8
        
         options.services.croc = {

     

       9
       9
       -
           enable = lib.mkEnableOption "croc relay";

     

       9
       9
       +
           enable = lib.mkEnableOption (lib.mdDoc "croc relay");

     

       10
       10
        
           ports = lib.mkOption {

     

       11
       11
        
             type = with types; listOf port;

     

       12
       12
        
             default = [9009 9010 9011 9012 9013];

     
···

       17
       17
        
             default = "pass123";

     

       18
       18
        
             description = lib.mdDoc "Password or passwordfile for the relay.";

     

       19
       19
        
           };

     

       20
       20
       -
           openFirewall = lib.mkEnableOption "opening of the peer port(s) in the firewall";

     

       21
       21
       -
           debug = lib.mkEnableOption "debug logs";

     

       20
       20
       +
           openFirewall = lib.mkEnableOption (lib.mdDoc "opening of the peer port(s) in the firewall");

     

       21
       21
       +
           debug = lib.mkEnableOption (lib.mdDoc "debug logs");

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
        
         config = lib.mkIf cfg.enable {

+1 -1

nixos/modules/services/networking/dante.nix

···

       19
       19
        
       

     

       20
       20
        
         options = {

     

       21
       21
        
           services.dante = {

     

       22
       22
       -
             enable = mkEnableOption "Dante SOCKS proxy";

     

       22
       22
       +
             enable = mkEnableOption (lib.mdDoc "Dante SOCKS proxy");

     

       23
       23
        
       

     

       24
       24
        
             config = mkOption {

     

       25
       25
        
               type        = types.lines;

+1 -1

nixos/modules/services/networking/dnscrypt-proxy2.nix

···

       6
       6
        
       

     

       7
       7
        
       {

     

       8
       8
        
         options.services.dnscrypt-proxy2 = {

     

       9
       9
       -
           enable = mkEnableOption "dnscrypt-proxy2";

     

       9
       9
       +
           enable = mkEnableOption (lib.mdDoc "dnscrypt-proxy2");

     

       10
       10
        
       

     

       11
       11
        
           settings = mkOption {

     

       12
       12
        
             description = lib.mdDoc ''

+1 -1

nixos/modules/services/networking/dnscrypt-wrapper.nix

···

       124
       124
        
         ###### interface

     

       125
       125
        
       

     

       126
       126
        
         options.services.dnscrypt-wrapper = {

     

       127
       127
       -
           enable = mkEnableOption "DNSCrypt wrapper";

     

       127
       127
       +
           enable = mkEnableOption (lib.mdDoc "DNSCrypt wrapper");

     

       128
       128
        
       

     

       129
       129
        
           address = mkOption {

     

       130
       130
        
             type = types.str;

+1 -1

nixos/modules/services/networking/dnsdist.nix

···

       11
       11
        
       in {

     

       12
       12
        
         options = {

     

       13
       13
        
           services.dnsdist = {

     

       14
       14
       -
             enable = mkEnableOption "dnsdist domain name server";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "dnsdist domain name server");

     

       15
       15
        
       

     

       16
       16
        
             listenAddress = mkOption {

     

       17
       17
        
               type = types.str;

+1 -1

nixos/modules/services/networking/doh-proxy-rust.nix

···

       10
       10
        
       

     

       11
       11
        
         options.services.doh-proxy-rust = {

     

       12
       12
        
       

     

       13
       13
       -
           enable = mkEnableOption "doh-proxy-rust";

     

       13
       13
       +
           enable = mkEnableOption (lib.mdDoc "doh-proxy-rust");

     

       14
       14
        
       

     

       15
       15
        
           flags = mkOption {

     

       16
       16
        
             type = types.listOf types.str;

+1 -1

nixos/modules/services/networking/envoy.nix

···

       16
       16
        
       

     

       17
       17
        
       {

     

       18
       18
        
         options.services.envoy = {

     

       19
       19
       -
           enable = mkEnableOption "Envoy reverse proxy";

     

       19
       19
       +
           enable = mkEnableOption (lib.mdDoc "Envoy reverse proxy");

     

       20
       20
        
       

     

       21
       21
        
           settings = mkOption {

     

       22
       22
        
             type = format.type;

+1 -1

nixos/modules/services/networking/ergo.nix

···

       33
       33
        
         options = {

     

       34
       34
        
       

     

       35
       35
        
           services.ergo = {

     

       36
       36
       -
             enable = mkEnableOption "Ergo service";

     

       36
       36
       +
             enable = mkEnableOption (lib.mdDoc "Ergo service");

     

       37
       37
        
       

     

       38
       38
        
             dataDir = mkOption {

     

       39
       39
        
               type = types.path;

+1 -1

nixos/modules/services/networking/ergochat.nix

···

       4
       4
        
         options = {

     

       5
       5
        
           services.ergochat = {

     

       6
       6
        
       

     

       7
       7
       -
             enable = lib.mkEnableOption "Ergo IRC daemon";

     

       7
       7
       +
             enable = lib.mkEnableOption (lib.mdDoc "Ergo IRC daemon");

     

       8
       8
        
       

     

       9
       9
        
             openFilesLimit = lib.mkOption {

     

       10
       10
        
               type = lib.types.int;

+1 -1

nixos/modules/services/networking/eternal-terminal.nix

···

       16
       16
        
       

     

       17
       17
        
           services.eternal-terminal = {

     

       18
       18
        
       

     

       19
       19
       -
             enable = mkEnableOption "Eternal Terminal server";

     

       19
       19
       +
             enable = mkEnableOption (lib.mdDoc "Eternal Terminal server");

     

       20
       20
        
       

     

       21
       21
        
             port = mkOption {

     

       22
       22
        
               default = 2022;

+3 -3

nixos/modules/services/networking/firefox-syncserver.nix

···

       118
       118
        
             };

     

       119
       119
        
       

     

       120
       120
        
             singleNode = {

     

       121
       121
       -
               enable = lib.mkEnableOption "auto-configuration for a simple single-node setup";

     

       121
       121
       +
               enable = lib.mkEnableOption (lib.mdDoc "auto-configuration for a simple single-node setup");

     

       122
       122
        
       

     

       123
       123
       -
               enableTLS = lib.mkEnableOption "automatic TLS setup";

     

       123
       123
       +
               enableTLS = lib.mkEnableOption (lib.mdDoc "automatic TLS setup");

     

       124
       124
        
       

     

       125
       125
       -
               enableNginx = lib.mkEnableOption "nginx virtualhost definitions";

     

       125
       125
       +
               enableNginx = lib.mkEnableOption (lib.mdDoc "nginx virtualhost definitions");

     

       126
       126
        
       

     

       127
       127
        
               hostname = lib.mkOption {

     

       128
       128
        
                 type = lib.types.str;

+1 -1

nixos/modules/services/networking/flannel.nix

···

       14
       14
        
         };

     

       15
       15
        
       in {

     

       16
       16
        
         options.services.flannel = {

     

       17
       17
       -
           enable = mkEnableOption "flannel";

     

       17
       17
       +
           enable = mkEnableOption (lib.mdDoc "flannel");

     

       18
       18
        
       

     

       19
       19
        
           package = mkOption {

     

       20
       20
        
             description = lib.mdDoc "Package to use for flannel";

+1 -1

nixos/modules/services/networking/freeradius.nix

···

       33
       33
        
         };

     

       34
       34
        
       

     

       35
       35
        
         freeradiusConfig = {

     

       36
       36
       -
           enable = mkEnableOption "the freeradius server";

     

       36
       36
       +
           enable = mkEnableOption (lib.mdDoc "the freeradius server");

     

       37
       37
        
       

     

       38
       38
        
           configDir = mkOption {

     

       39
       39
        
             type = types.path;

+1 -1

nixos/modules/services/networking/frr.nix

···

       51
       51
        
       

     

       52
       52
        
         serviceOptions = service:

     

       53
       53
        
           {

     

       54
       54
       -
             enable = mkEnableOption "the FRR ${toUpper service} routing protocol";

     

       54
       54
       +
             enable = mkEnableOption (lib.mdDoc "the FRR ${toUpper service} routing protocol");

     

       55
       55
        
       

     

       56
       56
        
             configFile = mkOption {

     

       57
       57
        
               type = types.nullOr types.path;

+1 -1

nixos/modules/services/networking/gateone.nix

···

       6
       6
        
       {

     

       7
       7
        
       options = {

     

       8
       8
        
           services.gateone = {

     

       9
       9
       -
             enable = mkEnableOption "GateOne server";

     

       9
       9
       +
             enable = mkEnableOption (lib.mdDoc "GateOne server");

     

       10
       10
        
             pidDir = mkOption {

     

       11
       11
        
               default = "/run/gateone";

     

       12
       12
        
               type = types.path;

+1 -1

nixos/modules/services/networking/gdomap.nix

···

       8
       8
        
         #

     

       9
       9
        
         options = {

     

       10
       10
        
           services.gdomap = {

     

       11
       11
       -
             enable = mkEnableOption "GNUstep Distributed Objects name server";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "GNUstep Distributed Objects name server");

     

       12
       12
        
          };

     

       13
       13
        
         };

     

       14
       14

+1 -1

nixos/modules/services/networking/ghostunnel.nix

···

       213
       213
        
       {

     

       214
       214
        
       

     

       215
       215
        
         options = {

     

       216
       216
       -
           services.ghostunnel.enable = mkEnableOption "ghostunnel";

     

       216
       216
       +
           services.ghostunnel.enable = mkEnableOption (lib.mdDoc "ghostunnel");

     

       217
       217
        
       

     

       218
       218
        
           services.ghostunnel.package = mkOption {

     

       219
       219
        
             description = lib.mdDoc "The ghostunnel package to use.";

+3 -3

nixos/modules/services/networking/globalprotect-vpn.nix

···

       14
       14
        
       

     

       15
       15
        
       {

     

       16
       16
        
         options.services.globalprotect = {

     

       17
       17
       -
           enable = mkEnableOption "globalprotect";

     

       17
       17
       +
           enable = mkEnableOption (lib.mdDoc "globalprotect");

     

       18
       18
        
       

     

       19
       19
        
           settings = mkOption {

     

       20
       20
       -
             description = ''

     

       20
       20
       +
             description = lib.mdDoc ''

     

       21
       21
        
               GlobalProtect-openconnect configuration. For more information, visit

     

       22
       22
       -
               <link xlink:href="https://github.com/yuezk/GlobalProtect-openconnect/wiki/Configuration"/>.

     

       22
       22
       +
               <https://github.com/yuezk/GlobalProtect-openconnect/wiki/Configuration>.

     

       23
       23
        
             '';

     

       24
       24
        
             default = { };

     

       25
       25
        
             example = {

+1 -1

nixos/modules/services/networking/go-neb.nix

···

       9
       9
        
         configFile = settingsFormat.generate "config.yaml" cfg.config;

     

       10
       10
        
       in {

     

       11
       11
        
         options.services.go-neb = {

     

       12
       12
       -
           enable = mkEnableOption "Extensible matrix bot written in Go";

     

       12
       12
       +
           enable = mkEnableOption (lib.mdDoc "Extensible matrix bot written in Go");

     

       13
       13
        
       

     

       14
       14
        
           bindAddress = mkOption {

     

       15
       15
        
             type = types.str;

+1 -1

nixos/modules/services/networking/go-shadowsocks2.nix

···

       5
       5
        
         cfg = config.services.go-shadowsocks2.server;

     

       6
       6
        
       in {

     

       7
       7
        
         options.services.go-shadowsocks2.server = {

     

       8
       8
       -
           enable = mkEnableOption "go-shadowsocks2 server";

     

       8
       8
       +
           enable = mkEnableOption (lib.mdDoc "go-shadowsocks2 server");

     

       9
       9
        
       

     

       10
       10
        
           listenAddress = mkOption {

     

       11
       11
        
             type = types.str;

+1 -1

nixos/modules/services/networking/gobgpd.nix

···

       8
       8
        
         confFile = format.generate "gobgpd.conf" cfg.settings;

     

       9
       9
        
       in {

     

       10
       10
        
         options.services.gobgpd = {

     

       11
       11
       -
           enable = mkEnableOption "GoBGP Routing Daemon";

     

       11
       11
       +
           enable = mkEnableOption (lib.mdDoc "GoBGP Routing Daemon");

     

       12
       12
        
       

     

       13
       13
        
           settings = mkOption {

     

       14
       14
        
             type = format.type;

+1 -1

nixos/modules/services/networking/gvpe.nix

···

       42
       42
        
       {

     

       43
       43
        
         options = {

     

       44
       44
        
           services.gvpe = {

     

       45
       45
       -
             enable = lib.mkEnableOption "gvpe";

     

       45
       45
       +
             enable = lib.mkEnableOption (lib.mdDoc "gvpe");

     

       46
       46
        
       

     

       47
       47
        
             nodename = mkOption {

     

       48
       48
        
               default = null;

+1 -1

nixos/modules/services/networking/headscale.nix

···

       12
       12
        
       {

     

       13
       13
        
         options = {

     

       14
       14
        
           services.headscale = {

     

       15
       15
       -
             enable = mkEnableOption "headscale, Open Source coordination server for Tailscale";

     

       15
       15
       +
             enable = mkEnableOption (lib.mdDoc "headscale, Open Source coordination server for Tailscale");

     

       16
       16
        
       

     

       17
       17
        
             package = mkOption {

     

       18
       18
        
               type = types.package;

+1 -1

nixos/modules/services/networking/https-dns-proxy.nix

···

       46
       46
        
         ###### interface

     

       47
       47
        
       

     

       48
       48
        
         options.services.https-dns-proxy = {

     

       49
       49
       -
           enable = mkEnableOption "https-dns-proxy daemon";

     

       49
       49
       +
           enable = mkEnableOption (lib.mdDoc "https-dns-proxy daemon");

     

       50
       50
        
       

     

       51
       51
        
           address = mkOption {

     

       52
       52
        
             description = lib.mdDoc "The address on which to listen";

+7 -7

nixos/modules/services/networking/hylafax/options.nix

···

       118
       118
        
       

     

       119
       119
        
         options.services.hylafax = {

     

       120
       120
        
       

     

       121
       121
       -
           enable = mkEnableOption "HylaFAX server";

     

       121
       121
       +
           enable = mkEnableOption (lib.mdDoc "HylaFAX server");

     

       122
       122
        
       

     

       123
       123
        
           autostart = mkOption {

     

       124
       124
        
             type = bool;

     
···

       271
       271
        
             '';

     

       272
       272
        
           };

     

       273
       273
        
       

     

       274
       274
       -
           faxcron.enable.spoolInit = mkEnableOption ''

     

       274
       274
       +
           faxcron.enable.spoolInit = mkEnableOption (lib.mdDoc ''

     

       275
       275
        
             Purge old files from the spooling area with

     

       276
       276
       -
             <filename>faxcron</filename>

     

       276
       276
       +
             {file}`faxcron`

     

       277
       277
        
             each time the spooling area is initialized.

     

       278
       278
       -
           '';

     

       278
       278
       +
           '');

     

       279
       279
        
           faxcron.enable.frequency = mkOption {

     

       280
       280
        
             type = nullOr nonEmptyStr;

     

       281
       281
        
             default = null;

     
···

       311
       311
        
             '';

     

       312
       312
        
           };

     

       313
       313
        
       

     

       314
       314
       -
           faxqclean.enable.spoolInit = mkEnableOption ''

     

       314
       314
       +
           faxqclean.enable.spoolInit = mkEnableOption (lib.mdDoc ''

     

       315
       315
        
             Purge old files from the spooling area with

     

       316
       316
       -
             <filename>faxqclean</filename>

     

       316
       316
       +
             {file}`faxqclean`

     

       317
       317
        
             each time the spooling area is initialized.

     

       318
       318
       -
           '';

     

       318
       318
       +
           '');

     

       319
       319
        
           faxqclean.enable.frequency = mkOption {

     

       320
       320
        
             type = nullOr nonEmptyStr;

     

       321
       321
        
             default = null;

+1 -1

nixos/modules/services/networking/i2p.nix

···

       7
       7
        
         homeDir = "/var/lib/i2p";

     

       8
       8
        
       in {

     

       9
       9
        
         ###### interface

     

       10
       10
       -
         options.services.i2p.enable = mkEnableOption "I2P router";

     

       10
       10
       +
         options.services.i2p.enable = mkEnableOption (lib.mdDoc "I2P router");

     

       11
       11
        
       

     

       12
       12
        
         ###### implementation

     

       13
       13
        
         config = mkIf cfg.enable {

+12 -12

nixos/modules/services/networking/i2pd.nix

···

       17
       17
        
         optionalNullInt = o: i: optional (i != null) (intOpt o i);

     

       18
       18
        
         optionalEmptyList = o: l: optional ([] != l) (lstOpt o l);

     

       19
       19
        
       

     

       20
       20
       -
         mkEnableTrueOption = name: mkEnableOption name // { default = true; };

     

       20
       20
       +
         mkEnableTrueOption = name: mkEnableOption (lib.mdDoc name) // { default = true; };

     

       21
       21
        
       

     

       22
       22
        
         mkEndpointOpt = name: addr: port: {

     

       23
       23
       -
           enable = mkEnableOption name;

     

       23
       23
       +
           enable = mkEnableOption (lib.mdDoc name);

     

       24
       24
        
           name = mkOption {

     

       25
       25
        
             type = types.str;

     

       26
       26
        
             default = name;

     
···

       276
       276
        
               '';

     

       277
       277
        
             };

     

       278
       278
        
       

     

       279
       279
       -
             logCLFTime = mkEnableOption "Full CLF-formatted date and time to log";

     

       279
       279
       +
             logCLFTime = mkEnableOption (lib.mdDoc "Full CLF-formatted date and time to log");

     

       280
       280
        
       

     

       281
       281
        
             address = mkOption {

     

       282
       282
        
               type = with types; nullOr str;

     
···

       383
       383
        
             };

     

       384
       384
        
       

     

       385
       385
        
             enableIPv4 = mkEnableTrueOption "IPv4 connectivity";

     

       386
       386
       -
             enableIPv6 = mkEnableOption "IPv6 connectivity";

     

       386
       386
       +
             enableIPv6 = mkEnableOption (lib.mdDoc "IPv6 connectivity");

     

       387
       387
        
             nat = mkEnableTrueOption "NAT bypass";

     

       388
       388
        
       

     

       389
       389
       -
             upnp.enable = mkEnableOption "UPnP service discovery";

     

       389
       389
       +
             upnp.enable = mkEnableOption (lib.mdDoc "UPnP service discovery");

     

       390
       390
        
             upnp.name = mkOption {

     

       391
       391
        
               type = types.str;

     

       392
       392
        
               default = "I2Pd";

     
···

       406
       406
        
               '';

     

       407
       407
        
             };

     

       408
       408
        
       

     

       409
       409
       -
             reseed.verify = mkEnableOption "SU3 signature verification";

     

       409
       409
       +
             reseed.verify = mkEnableOption (lib.mdDoc "SU3 signature verification");

     

       410
       410
        
       

     

       411
       411
        
             reseed.file = mkOption {

     

       412
       412
        
               type = with types; nullOr str;

     
···

       467
       467
        
               '';

     

       468
       468
        
             };

     

       469
       469
        
       

     

       470
       470
       -
             trust.enable = mkEnableOption "Explicit trust options";

     

       470
       470
       +
             trust.enable = mkEnableOption (lib.mdDoc "Explicit trust options");

     

       471
       471
        
       

     

       472
       472
        
             trust.family = mkOption {

     

       473
       473
        
               type = with types; nullOr str;

     
···

       485
       485
        
               '';

     

       486
       486
        
             };

     

       487
       487
        
       

     

       488
       488
       -
             trust.hidden = mkEnableOption "Router concealment";

     

       488
       488
       +
             trust.hidden = mkEnableOption (lib.mdDoc "Router concealment");

     

       489
       489
        
       

     

       490
       490
        
             websocket = mkEndpointOpt "websockets" "127.0.0.1" 7666;

     

       491
       491
        
       

     
···

       493
       493
        
             exploratory.outbound = i2cpOpts "exploratory";

     

       494
       494
        
       

     

       495
       495
        
             ntcp2.enable = mkEnableTrueOption "NTCP2";

     

       496
       496
       -
             ntcp2.published = mkEnableOption "NTCP2 publication";

     

       496
       496
       +
             ntcp2.published = mkEnableOption (lib.mdDoc "NTCP2 publication");

     

       497
       497
        
             ntcp2.port = mkOption {

     

       498
       498
        
               type = types.int;

     

       499
       499
        
               default = 0;

     
···

       550
       550
        
               '';

     

       551
       551
        
             };

     

       552
       552
        
       

     

       553
       553
       -
             yggdrasil.enable = mkEnableOption "Yggdrasil";

     

       553
       553
       +
             yggdrasil.enable = mkEnableOption (lib.mdDoc "Yggdrasil");

     

       554
       554
        
       

     

       555
       555
        
             yggdrasil.address = mkOption {

     

       556
       556
        
               type = with types; nullOr str;

     
···

       563
       563
        
       

     

       564
       564
        
             proto.http = (mkEndpointOpt "http" "127.0.0.1" 7070) // {

     

       565
       565
        
       

     

       566
       566
       -
               auth = mkEnableOption "Webconsole authentication";

     

       566
       566
       +
               auth = mkEnableOption (lib.mdDoc "Webconsole authentication");

     

       567
       567
        
       

     

       568
       568
        
               user = mkOption {

     

       569
       569
        
                 type = types.str;

     
···

       608
       608
        
             };

     

       609
       609
        
             proto.socksProxy = (mkKeyedEndpointOpt "socksproxy" "127.0.0.1" 4447 "socksproxy-keys.dat")

     

       610
       610
        
             // {

     

       611
       611
       -
               outproxyEnable = mkEnableOption "SOCKS outproxy";

     

       611
       611
       +
               outproxyEnable = mkEnableOption (lib.mdDoc "SOCKS outproxy");

     

       612
       612
        
               outproxy = mkOption {

     

       613
       613
        
                 type = types.str;

     

       614
       614
        
                 default = "127.0.0.1";

+1 -1

nixos/modules/services/networking/icecream/daemon.nix

···

       12
       12
        
       

     

       13
       13
        
           services.icecream.daemon = {

     

       14
       14
        
       

     

       15
       15
       -
            enable = mkEnableOption "Icecream Daemon";

     

       15
       15
       +
            enable = mkEnableOption (lib.mdDoc "Icecream Daemon");

     

       16
       16
        
       

     

       17
       17
        
             openFirewall = mkOption {

     

       18
       18
        
               type = types.bool;

+1 -1

nixos/modules/services/networking/icecream/scheduler.nix

···

       11
       11
        
         options = {

     

       12
       12
        
       

     

       13
       13
        
           services.icecream.scheduler = {

     

       14
       14
       -
             enable = mkEnableOption "Icecream Scheduler";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "Icecream Scheduler");

     

       15
       15
        
       

     

       16
       16
        
             netName = mkOption {

     

       17
       17
        
               type = types.nullOr types.str;

+1 -1

nixos/modules/services/networking/inspircd.nix

···

       12
       12
        
       

     

       13
       13
        
         options = {

     

       14
       14
        
           services.inspircd = {

     

       15
       15
       -
             enable = lib.mkEnableOption "InspIRCd";

     

       15
       15
       +
             enable = lib.mkEnableOption (lib.mdDoc "InspIRCd");

     

       16
       16
        
       

     

       17
       17
        
             package = lib.mkOption {

     

       18
       18
        
               type = lib.types.package;

+1 -1

nixos/modules/services/networking/iperf3.nix

···

       3
       3
        
         cfg = config.services.iperf3;

     

       4
       4
        
       

     

       5
       5
        
         api = {

     

       6
       6
       -
           enable = mkEnableOption "iperf3 network throughput testing server";

     

       6
       6
       +
           enable = mkEnableOption (lib.mdDoc "iperf3 network throughput testing server");

     

       7
       7
        
           port = mkOption {

     

       8
       8
        
             type        = types.ints.u16;

     

       9
       9
        
             default     = 5201;

+1 -1

nixos/modules/services/networking/ircd-hybrid/default.nix

···

       36
       36
        
       

     

       37
       37
        
           services.ircdHybrid = {

     

       38
       38
        
       

     

       39
       39
       -
             enable = mkEnableOption "IRCD";

     

       39
       39
       +
             enable = mkEnableOption (lib.mdDoc "IRCD");

     

       40
       40
        
       

     

       41
       41
        
             serverName = mkOption {

     

       42
       42
        
               default = "hades.arpa";

+3 -3

nixos/modules/services/networking/iscsi/initiator.nix

···

       4
       4
        
       in

     

       5
       5
        
       {

     

       6
       6
        
         options.services.openiscsi = with types; {

     

       7
       7
       -
           enable = mkEnableOption "the openiscsi iscsi daemon";

     

       8
       8
       -
           enableAutoLoginOut = mkEnableOption ''

     

       7
       7
       +
           enable = mkEnableOption (lib.mdDoc "the openiscsi iscsi daemon");

     

       8
       8
       +
           enableAutoLoginOut = mkEnableOption (lib.mdDoc ''

     

       9
       9
        
             automatic login and logout of all automatic targets.

     

       10
       10
        
             You probably do not want this.

     

       11
       11
       -
           '';

     

       11
       11
       +
           '');

     

       12
       12
        
           discoverPortal = mkOption {

     

       13
       13
        
             type = nullOr str;

     

       14
       14
        
             default = null;

+1 -1

nixos/modules/services/networking/iscsi/target.nix

···

       9
       9
        
         ###### interface

     

       10
       10
        
         options = {

     

       11
       11
        
           services.target = with types; {

     

       12
       12
       -
             enable = mkEnableOption "the kernel's LIO iscsi target";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "the kernel's LIO iscsi target");

     

       13
       13
        
       

     

       14
       14
        
             config = mkOption {

     

       15
       15
        
               type = attrs;

+1 -1

nixos/modules/services/networking/iwd.nix

···

       17
       17
        
       in

     

       18
       18
        
       {

     

       19
       19
        
         options.networking.wireless.iwd = {

     

       20
       20
       -
           enable = mkEnableOption "iwd";

     

       20
       20
       +
           enable = mkEnableOption (lib.mdDoc "iwd");

     

       21
       21
        
       

     

       22
       22
        
           settings = mkOption {

     

       23
       23
        
             type = ini.type;

+1 -1

nixos/modules/services/networking/jibri/default.nix

···

       89
       89
        
       in

     

       90
       90
        
       {

     

       91
       91
        
         options.services.jibri = with types; {

     

       92
       92
       -
           enable = mkEnableOption "Jitsi BRoadcasting Infrastructure. Currently Jibri must be run on a host that is also running <option>services.jitsi-meet.enable</option>, so for most use cases it will be simpler to run <option>services.jitsi-meet.jibri.enable</option>";

     

       92
       92
       +
           enable = mkEnableOption (lib.mdDoc "Jitsi BRoadcasting Infrastructure. Currently Jibri must be run on a host that is also running {option}`services.jitsi-meet.enable`, so for most use cases it will be simpler to run {option}`services.jitsi-meet.jibri.enable`");

     

       93
       93
        
           config = mkOption {

     

       94
       94
        
             type = attrs;

     

       95
       95
        
             default = { };

+1 -1

nixos/modules/services/networking/jicofo.nix

···

       7
       7
        
       in

     

       8
       8
        
       {

     

       9
       9
        
         options.services.jicofo = with types; {

     

       10
       10
       -
           enable = mkEnableOption "Jitsi Conference Focus - component of Jitsi Meet";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "Jitsi Conference Focus - component of Jitsi Meet");

     

       11
       11
        
       

     

       12
       12
        
           xmppHost = mkOption {

     

       13
       13
        
             type = str;

+1 -1

nixos/modules/services/networking/jitsi-videobridge.nix

···

       51
       51
        
       in

     

       52
       52
        
       {

     

       53
       53
        
         options.services.jitsi-videobridge = with types; {

     

       54
       54
       -
           enable = mkEnableOption "Jitsi Videobridge, a WebRTC compatible video router";

     

       54
       54
       +
           enable = mkEnableOption (lib.mdDoc "Jitsi Videobridge, a WebRTC compatible video router");

     

       55
       55
        
       

     

       56
       56
        
           config = mkOption {

     

       57
       57
        
             type = attrs;

+4 -4

nixos/modules/services/networking/kea.nix

···

       41
       41
        
             default = {};

     

       42
       42
        
             type = submodule {

     

       43
       43
        
               options = {

     

       44
       44
       -
                 enable = mkEnableOption "Kea Control Agent";

     

       44
       44
       +
                 enable = mkEnableOption (lib.mdDoc "Kea Control Agent");

     

       45
       45
        
       

     

       46
       46
        
                 extraArgs = mkOption {

     

       47
       47
        
                   type = listOf str;

     
···

       80
       80
        
             default = {};

     

       81
       81
        
             type = submodule {

     

       82
       82
        
               options = {

     

       83
       83
       -
                 enable = mkEnableOption "Kea DHCP4 server";

     

       83
       83
       +
                 enable = mkEnableOption (lib.mdDoc "Kea DHCP4 server");

     

       84
       84
        
       

     

       85
       85
        
                 extraArgs = mkOption {

     

       86
       86
        
                   type = listOf str;

     
···

       140
       140
        
             default = {};

     

       141
       141
        
             type = submodule {

     

       142
       142
        
               options = {

     

       143
       143
       -
                 enable = mkEnableOption "Kea DHCP6 server";

     

       143
       143
       +
                 enable = mkEnableOption (lib.mdDoc "Kea DHCP6 server");

     

       144
       144
        
       

     

       145
       145
        
                 extraArgs = mkOption {

     

       146
       146
        
                   type = listOf str;

     
···

       201
       201
        
             default = {};

     

       202
       202
        
             type = submodule {

     

       203
       203
        
               options = {

     

       204
       204
       -
                 enable = mkEnableOption "Kea DDNS server";

     

       204
       204
       +
                 enable = mkEnableOption (lib.mdDoc "Kea DDNS server");

     

       205
       205
        
       

     

       206
       206
        
                 extraArgs = mkOption {

     

       207
       207
        
                   type = listOf str;

+1 -1

nixos/modules/services/networking/knot.nix

···

       37
       37
        
       in {

     

       38
       38
        
         options = {

     

       39
       39
        
           services.knot = {

     

       40
       40
       -
             enable = mkEnableOption "Knot authoritative-only DNS server";

     

       40
       40
       +
             enable = mkEnableOption (lib.mdDoc "Knot authoritative-only DNS server");

     

       41
       41
        
       

     

       42
       42
        
             extraArgs = mkOption {

     

       43
       43
        
               type = types.listOf types.str;

+1 -1

nixos/modules/services/networking/libreswan.nix

···

       47
       47
        
       

     

       48
       48
        
           services.libreswan = {

     

       49
       49
        
       

     

       50
       50
       -
             enable = mkEnableOption "Libreswan IPsec service";

     

       50
       50
       +
             enable = mkEnableOption (lib.mdDoc "Libreswan IPsec service");

     

       51
       51
        
       

     

       52
       52
        
             configSetup = mkOption {

     

       53
       53
        
               type = types.lines;

+1 -1

nixos/modules/services/networking/lldpd.nix

···

       9
       9
        
       

     

       10
       10
        
       {

     

       11
       11
        
         options.services.lldpd = {

     

       12
       12
       -
           enable = mkEnableOption "Link Layer Discovery Protocol Daemon";

     

       12
       12
       +
           enable = mkEnableOption (lib.mdDoc "Link Layer Discovery Protocol Daemon");

     

       13
       13
        
       

     

       14
       14
        
           extraArgs = mkOption {

     

       15
       15
        
             type = types.listOf types.str;

+1 -1

nixos/modules/services/networking/lokinet.nix

···

       7
       7
        
         configFile = settingsFormat.generate "lokinet.ini" (lib.filterAttrsRecursive (n: v: v != null) cfg.settings);

     

       8
       8
        
       in with lib; {

     

       9
       9
        
         options.services.lokinet = {

     

       10
       10
       -
           enable = mkEnableOption "Lokinet daemon";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "Lokinet daemon");

     

       11
       11
        
       

     

       12
       12
        
           package = mkOption {

     

       13
       13
        
             type = types.package;

+2 -2

nixos/modules/services/networking/lxd-image-server.nix

···

       11
       11
        
       {

     

       12
       12
        
         options = {

     

       13
       13
        
           services.lxd-image-server = {

     

       14
       14
       -
             enable = mkEnableOption "lxd-image-server";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "lxd-image-server");

     

       15
       15
        
       

     

       16
       16
        
             group = mkOption {

     

       17
       17
        
               type = types.str;

     
···

       31
       31
        
             };

     

       32
       32
        
       

     

       33
       33
        
             nginx = {

     

       34
       34
       -
               enable = mkEnableOption "nginx";

     

       34
       34
       +
               enable = mkEnableOption (lib.mdDoc "nginx");

     

       35
       35
        
               domain = mkOption {

     

       36
       36
        
                 type = types.str;

     

       37
       37
        
                 description = lib.mdDoc "Domain to use for nginx virtual host.";

+1 -1

nixos/modules/services/networking/magic-wormhole-mailbox-server.nix

···

       9
       9
        
       in

     

       10
       10
        
       {

     

       11
       11
        
         options.services.magic-wormhole-mailbox-server = {

     

       12
       12
       -
           enable = mkEnableOption "Enable Magic Wormhole Mailbox Server";

     

       12
       12
       +
           enable = mkEnableOption (lib.mdDoc "Enable Magic Wormhole Mailbox Server");

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         config = mkIf cfg.enable {

+1 -1

nixos/modules/services/networking/matterbridge.nix

···

       17
       17
        
       {

     

       18
       18
        
         options = {

     

       19
       19
        
           services.matterbridge = {

     

       20
       20
       -
             enable = mkEnableOption "Matterbridge chat platform bridge";

     

       20
       20
       +
             enable = mkEnableOption (lib.mdDoc "Matterbridge chat platform bridge");

     

       21
       21
        
       

     

       22
       22
        
             configPath = mkOption {

     

       23
       23
        
               type = with types; nullOr str;

+2 -2

nixos/modules/services/networking/miniupnpd.nix

···

       19
       19
        
       {

     

       20
       20
        
         options = {

     

       21
       21
        
           services.miniupnpd = {

     

       22
       22
       -
             enable = mkEnableOption "MiniUPnP daemon";

     

       22
       22
       +
             enable = mkEnableOption (lib.mdDoc "MiniUPnP daemon");

     

       23
       23
        
       

     

       24
       24
        
             externalInterface = mkOption {

     

       25
       25
        
               type = types.str;

     
···

       36
       36
        
               '';

     

       37
       37
        
             };

     

       38
       38
        
       

     

       39
       39
       -
             natpmp = mkEnableOption "NAT-PMP support";

     

       39
       39
       +
             natpmp = mkEnableOption (lib.mdDoc "NAT-PMP support");

     

       40
       40
        
       

     

       41
       41
        
             upnp = mkOption {

     

       42
       42
        
               default = true;

+1 -1

nixos/modules/services/networking/miredo.nix

···

       20
       20
        
       

     

       21
       21
        
           services.miredo = {

     

       22
       22
        
       

     

       23
       23
       -
             enable = mkEnableOption "the Miredo IPv6 tunneling service";

     

       23
       23
       +
             enable = mkEnableOption (lib.mdDoc "the Miredo IPv6 tunneling service");

     

       24
       24
        
       

     

       25
       25
        
             package = mkOption {

     

       26
       26
        
               type = types.package;

+1 -1

nixos/modules/services/networking/mjpg-streamer.nix

···

       12
       12
        
       

     

       13
       13
        
           services.mjpg-streamer = {

     

       14
       14
        
       

     

       15
       15
       -
             enable = mkEnableOption "mjpg-streamer webcam streamer";

     

       15
       15
       +
             enable = mkEnableOption (lib.mdDoc "mjpg-streamer webcam streamer");

     

       16
       16
        
       

     

       17
       17
        
             inputPlugin = mkOption {

     

       18
       18
        
               type = types.str;

+1 -1

nixos/modules/services/networking/monero.nix

···

       50
       50
        
       

     

       51
       51
        
           services.monero = {

     

       52
       52
        
       

     

       53
       53
       -
             enable = mkEnableOption "Monero node daemon";

     

       53
       53
       +
             enable = mkEnableOption (lib.mdDoc "Monero node daemon");

     

       54
       54
        
       

     

       55
       55
        
             dataDir = mkOption {

     

       56
       56
        
               type = types.str;

+1 -1

nixos/modules/services/networking/morty.nix

···

       17
       17
        
           services.morty = {

     

       18
       18
        
       

     

       19
       19
        
             enable = mkEnableOption

     

       20
       20
       -
               "Morty proxy server. See https://github.com/asciimoo/morty";

     

       20
       20
       +
               (lib.mdDoc "Morty proxy server. See https://github.com/asciimoo/morty");

     

       21
       21
        
       

     

       22
       22
        
             ipv6 = mkOption {

     

       23
       23
        
               type = types.bool;

+1 -1

nixos/modules/services/networking/mosquitto.nix

···

       443
       443
        
         };

     

       444
       444
        
       

     

       445
       445
        
         globalOptions = with types; {

     

       446
       446
       -
           enable = mkEnableOption "the MQTT Mosquitto broker";

     

       446
       446
       +
           enable = mkEnableOption (lib.mdDoc "the MQTT Mosquitto broker");

     

       447
       447
        
       

     

       448
       448
        
           package = mkOption {

     

       449
       449
        
             type = package;

+1 -1

nixos/modules/services/networking/mtprotoproxy.nix

···

       37
       37
        
       

     

       38
       38
        
           services.mtprotoproxy = {

     

       39
       39
        
       

     

       40
       40
       -
             enable = mkEnableOption "mtprotoproxy";

     

       40
       40
       +
             enable = mkEnableOption (lib.mdDoc "mtprotoproxy");

     

       41
       41
        
       

     

       42
       42
        
             port = mkOption {

     

       43
       43
        
               type = types.int;

+1 -1

nixos/modules/services/networking/mtr-exporter.nix

···

       9
       9
        
         options = {

     

       10
       10
        
           services = {

     

       11
       11
        
             mtr-exporter = {

     

       12
       12
       -
               enable = mkEnableOption "a Prometheus exporter for MTR";

     

       12
       12
       +
               enable = mkEnableOption (lib.mdDoc "a Prometheus exporter for MTR");

     

       13
       13
        
       

     

       14
       14
        
               target = mkOption {

     

       15
       15
        
                 type = types.str;

+1 -1

nixos/modules/services/networking/multipath.nix

···

       22
       22
        
       

     

       23
       23
        
         options.services.multipath = with types; {

     

       24
       24
        
       

     

       25
       25
       -
           enable = mkEnableOption "the device mapper multipath (DM-MP) daemon";

     

       25
       25
       +
           enable = mkEnableOption (lib.mdDoc "the device mapper multipath (DM-MP) daemon");

     

       26
       26
        
       

     

       27
       27
        
           package = mkOption {

     

       28
       28
        
             type = package;

+1 -1

nixos/modules/services/networking/mxisd.nix

···

       37
       37
        
       in {

     

       38
       38
        
         options = {

     

       39
       39
        
           services.mxisd = {

     

       40
       40
       -
             enable = mkEnableOption "matrix federated identity server";

     

       40
       40
       +
             enable = mkEnableOption (lib.mdDoc "matrix federated identity server");

     

       41
       41
        
       

     

       42
       42
        
             package = mkOption {

     

       43
       43
        
               type = types.package;

+1 -1

nixos/modules/services/networking/namecoind.nix

···

       44
       44
        
       

     

       45
       45
        
           services.namecoind = {

     

       46
       46
        
       

     

       47
       47
       -
             enable = mkEnableOption "namecoind, Namecoin client";

     

       47
       47
       +
             enable = mkEnableOption (lib.mdDoc "namecoind, Namecoin client");

     

       48
       48
        
       

     

       49
       49
        
             wallet = mkOption {

     

       50
       50
        
               type = types.path;

+1 -1

nixos/modules/services/networking/nar-serve.nix

···

       10
       10
        
         };

     

       11
       11
        
         options = {

     

       12
       12
        
           services.nar-serve = {

     

       13
       13
       -
             enable = mkEnableOption "Serve NAR file contents via HTTP";

     

       13
       13
       +
             enable = mkEnableOption (lib.mdDoc "Serve NAR file contents via HTTP");

     

       14
       14
        
       

     

       15
       15
        
             port = mkOption {

     

       16
       16
        
               type = types.port;

+2 -2

nixos/modules/services/networking/nats.nix

···

       16
       16
        
       

     

       17
       17
        
         options = {

     

       18
       18
        
           services.nats = {

     

       19
       19
       -
             enable = mkEnableOption "NATS messaging system";

     

       19
       19
       +
             enable = mkEnableOption (lib.mdDoc "NATS messaging system");

     

       20
       20
        
       

     

       21
       21
        
             user = mkOption {

     

       22
       22
        
               type = types.str;

     
···

       39
       39
        
               '';

     

       40
       40
        
             };

     

       41
       41
        
       

     

       42
       42
       -
             jetstream = mkEnableOption "JetStream";

     

       42
       42
       +
             jetstream = mkEnableOption (lib.mdDoc "JetStream");

     

       43
       43
        
       

     

       44
       44
        
             port = mkOption {

     

       45
       45
        
               default = 4222;

+1 -1

nixos/modules/services/networking/nbd.nix

···

       43
       43
        
         options = {

     

       44
       44
        
           services.nbd = {

     

       45
       45
        
             server = {

     

       46
       46
       -
               enable = mkEnableOption "the Network Block Device (nbd) server";

     

       46
       46
       +
               enable = mkEnableOption (lib.mdDoc "the Network Block Device (nbd) server");

     

       47
       47
        
       

     

       48
       48
        
               listenPort = mkOption {

     

       49
       49
        
                 type = types.port;

+7 -7

nixos/modules/services/networking/ncdns.nix

···

       50
       50
        
       

     

       51
       51
        
           services.ncdns = {

     

       52
       52
        
       

     

       53
       53
       -
             enable = mkEnableOption ''

     

       53
       53
       +
             enable = mkEnableOption (lib.mdDoc ''

     

       54
       54
        
               ncdns, a Go daemon to bridge Namecoin to DNS.

     

       55
       55
       -
               To resolve .bit domains set <literal>services.namecoind.enable = true;</literal>

     

       55
       55
       +
               To resolve .bit domains set `services.namecoind.enable = true;`

     

       56
       56
        
               and an RPC username/password

     

       57
       57
       -
             '';

     

       57
       57
       +
             '');

     

       58
       58
        
       

     

       59
       59
        
             address = mkOption {

     

       60
       60
        
               type = types.str;

     
···

       112
       112
        
               '';

     

       113
       113
        
             };

     

       114
       114
        
       

     

       115
       115
       -
             dnssec.enable = mkEnableOption ''

     

       115
       115
       +
             dnssec.enable = mkEnableOption (lib.mdDoc ''

     

       116
       116
        
               DNSSEC support in ncdns. This will generate KSK and ZSK keypairs

     

       117
       117
        
               (unless provided via the options

     

       118
       118
       -
               <option>services.ncdns.dnssec.publicKey</option>,

     

       119
       119
       -
               <option>services.ncdns.dnssec.privateKey</option> etc.) and add a trust

     

       118
       118
       +
               {option}`services.ncdns.dnssec.publicKey`,

     

       119
       119
       +
               {option}`services.ncdns.dnssec.privateKey` etc.) and add a trust

     

       120
       120
        
               anchor to recursive resolvers

     

       121
       121
       -
             '';

     

       121
       121
       +
             '');

     

       122
       122
        
       

     

       123
       123
        
             dnssec.keys.public = mkOption {

     

       124
       124
        
               type = types.path;

+5 -5

nixos/modules/services/networking/ndppd.nix

···

       103
       103
        
       

     

       104
       104
        
       in {

     

       105
       105
        
         options.services.ndppd = {

     

       106
       106
       -
           enable = mkEnableOption "daemon that proxies NDP (Neighbor Discovery Protocol) messages between interfaces";

     

       106
       106
       +
           enable = mkEnableOption (lib.mdDoc "daemon that proxies NDP (Neighbor Discovery Protocol) messages between interfaces");

     

       107
       107
        
           interface = mkOption {

     

       108
       108
        
             type = types.nullOr types.str;

     

       109
       109
       -
             description = ''

     

       109
       109
       +
             description = lib.mdDoc ''

     

       110
       110
        
               Interface which is on link-level with router.

     

       111
       111
       -
               (Legacy option, use services.ndppd.proxies.&lt;interface&gt;.rules.&lt;network&gt; instead)

     

       111
       111
       +
               (Legacy option, use services.ndppd.proxies.\<interface\>.rules.\<network\> instead)

     

       112
       112
        
             '';

     

       113
       113
        
             default = null;

     

       114
       114
        
             example = "eth0";

     

       115
       115
        
           };

     

       116
       116
        
           network = mkOption {

     

       117
       117
        
             type = types.nullOr types.str;

     

       118
       118
       -
             description = ''

     

       118
       118
       +
             description = lib.mdDoc ''

     

       119
       119
        
               Network that we proxy.

     

       120
       120
       -
               (Legacy option, use services.ndppd.proxies.&lt;interface&gt;.rules.&lt;network&gt; instead)

     

       120
       120
       +
               (Legacy option, use services.ndppd.proxies.\<interface\>.rules.\<network\> instead)

     

       121
       121
        
             '';

     

       122
       122
        
             default = null;

     

       123
       123
        
             example = "1111::/64";

+2 -2

nixos/modules/services/networking/netbird.nix

···

       10
       10
        
         meta.maintainers = with maintainers; [ misuzu ];

     

       11
       11
        
       

     

       12
       12
        
         options.services.netbird = {

     

       13
       13
       -
           enable = mkEnableOption "Netbird daemon";

     

       13
       13
       +
           enable = mkEnableOption (lib.mdDoc "Netbird daemon");

     

       14
       14
        
           package = mkOption {

     

       15
       15
        
             type = types.package;

     

       16
       16
        
             default = pkgs.netbird;

     

       17
       17
        
             defaultText = literalExpression "pkgs.netbird";

     

       18
       18
       -
             description = "The package to use for netbird";

     

       18
       18
       +
             description = lib.mdDoc "The package to use for netbird";

     

       19
       19
        
           };

     

       20
       20
        
         };

     

       21
       21

+3 -3

nixos/modules/services/networking/nghttpx/nghttpx-options.nix

···

       1
       1
        
       { lib, ... }:

     

       2
       2
        
       { options.services.nghttpx = {

     

       3
       3
       -
           enable = lib.mkEnableOption "nghttpx";

     

       3
       3
       +
           enable = lib.mkEnableOption (lib.mdDoc "nghttpx");

     

       4
       4
        
       

     

       5
       5
        
           frontends = lib.mkOption {

     

       6
       6
        
             type        = lib.types.listOf (lib.types.submodule (import ./frontend-submodule.nix));

     
···

       131
       131
        
           rlimit-nofile = lib.mkOption {

     

       132
       132
        
             type        = lib.types.int;

     

       133
       133
        
             default     = 0;

     

       134
       134
       -
             description = ''

     

       135
       135
       -
               Set maximum number of open files (RLIMIT_NOFILE) to &lt;N&gt;. If 0

     

       134
       134
       +
             description = lib.mdDoc ''

     

       135
       135
       +
               Set maximum number of open files (RLIMIT_NOFILE) to \<N\>. If 0

     

       136
       136
        
               is given, nghttpx does not set the limit.

     

       137
       137
        
       

     

       138
       138
        
               Please see https://nghttp2.org/documentation/nghttpx.1.html#cmdoption-nghttpx--rlimit-nofile

+1 -1

nixos/modules/services/networking/ngircd.nix

···

       20
       20
        
       in {

     

       21
       21
        
         options = {

     

       22
       22
        
           services.ngircd = {

     

       23
       23
       -
             enable = mkEnableOption "the ngircd IRC server";

     

       23
       23
       +
             enable = mkEnableOption (lib.mdDoc "the ngircd IRC server");

     

       24
       24
        
       

     

       25
       25
        
             config = mkOption {

     

       26
       26
        
               description = lib.mdDoc "The ngircd configuration (see ngircd.conf(5)).";

+1 -1

nixos/modules/services/networking/nix-serve.nix

···

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.nix-serve = {

     

       11
       11
       -
             enable = mkEnableOption "nix-serve, the standalone Nix binary cache server";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "nix-serve, the standalone Nix binary cache server");

     

       12
       12
        
       

     

       13
       13
        
             port = mkOption {

     

       14
       14
        
               type = types.port;

+1 -1

nixos/modules/services/networking/nntp-proxy.nix

···

       59
       59
        
         options = {

     

       60
       60
        
       

     

       61
       61
        
           services.nntp-proxy = {

     

       62
       62
       -
             enable = mkEnableOption "NNTP-Proxy";

     

       62
       62
       +
             enable = mkEnableOption (lib.mdDoc "NNTP-Proxy");

     

       63
       63
        
       

     

       64
       64
        
             upstreamServer = mkOption {

     

       65
       65
        
               type = types.str;

+3 -3

nixos/modules/services/networking/nomad.nix

···

       8
       8
        
         ##### interface

     

       9
       9
        
         options = {

     

       10
       10
        
           services.nomad = {

     

       11
       11
       -
             enable = mkEnableOption "Nomad, a distributed, highly available, datacenter-aware scheduler";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "Nomad, a distributed, highly available, datacenter-aware scheduler");

     

       12
       12
        
       

     

       13
       13
        
             package = mkOption {

     

       14
       14
        
               type = types.package;

     
···

       22
       22
        
             extraPackages = mkOption {

     

       23
       23
        
               type = types.listOf types.package;

     

       24
       24
        
               default = [ ];

     

       25
       25
       -
               description = ''

     

       26
       26
       -
                 Extra packages to add to <envar>PATH</envar> for the Nomad agent process.

     

       25
       25
       +
               description = lib.mdDoc ''

     

       26
       26
       +
                 Extra packages to add to {env}`PATH` for the Nomad agent process.

     

       27
       27
        
               '';

     

       28
       28
        
               example = literalExpression ''

     

       29
       29
        
                 with pkgs; [ cni-plugins ]

+8 -8

nixos/modules/services/networking/nsd.nix

···

       262
       262
        
               '';

     

       263
       263
        
             };

     

       264
       264
        
       

     

       265
       265
       -
             dnssec = mkEnableOption "DNSSEC";

     

       265
       265
       +
             dnssec = mkEnableOption (lib.mdDoc "DNSSEC");

     

       266
       266
        
       

     

       267
       267
        
             dnssecPolicy = {

     

       268
       268
        
               algorithm = mkOption {

     
···

       382
       382
        
               type = types.listOf types.str;

     

       383
       383
        
               default = [];

     

       384
       384
        
               example = [ "192.0.2.0/24 NOKEY" "192.0.2.0/24 my_tsig_key_name" ];

     

       385
       385
       -
               description = ''

     

       385
       385
       +
               description = lib.mdDoc ''

     

       386
       386
        
                 Allow these IPs and TSIG to transfer zones, addr TSIG|NOKEY|BLOCKED

     

       387
       387
       -
                 address range 192.0.2.0/24, 1.2.3.4&amp;255.255.0.0, 3.0.2.20-3.0.2.40

     

       387
       387
       +
                 address range 192.0.2.0/24, 1.2.3.4&255.255.0.0, 3.0.2.20-3.0.2.40

     

       388
       388
        
               '';

     

       389
       389
        
             };

     

       390
       390
        
       

     
···

       478
       478
        
         # options are ordered alphanumerically

     

       479
       479
        
         options.services.nsd = {

     

       480
       480
        
       

     

       481
       481
       -
           enable = mkEnableOption "NSD authoritative DNS server";

     

       481
       481
       +
           enable = mkEnableOption (lib.mdDoc "NSD authoritative DNS server");

     

       482
       482
        
       

     

       483
       483
       -
           bind8Stats = mkEnableOption "BIND8 like statistics";

     

       483
       483
       +
           bind8Stats = mkEnableOption (lib.mdDoc "BIND8 like statistics");

     

       484
       484
        
       

     

       485
       485
        
           dnssecInterval = mkOption {

     

       486
       486
        
             type = types.str;

     
···

       616
       616
        
             '';

     

       617
       617
        
           };

     

       618
       618
        
       

     

       619
       619
       -
           roundRobin = mkEnableOption "round robin rotation of records";

     

       619
       619
       +
           roundRobin = mkEnableOption (lib.mdDoc "round robin rotation of records");

     

       620
       620
        
       

     

       621
       621
        
           serverCount = mkOption {

     

       622
       622
        
             type = types.int;

     
···

       735
       735
        
       

     

       736
       736
        
           ratelimit = {

     

       737
       737
        
       

     

       738
       738
       -
             enable = mkEnableOption "ratelimit capabilities";

     

       738
       738
       +
             enable = mkEnableOption (lib.mdDoc "ratelimit capabilities");

     

       739
       739
        
       

     

       740
       740
        
             ipv4PrefixLength = mkOption {

     

       741
       741
        
               type = types.nullOr types.int;

     
···

       796
       796
        
       

     

       797
       797
        
           remoteControl = {

     

       798
       798
        
       

     

       799
       799
       -
             enable = mkEnableOption "remote control via nsd-control";

     

       799
       799
       +
             enable = mkEnableOption (lib.mdDoc "remote control via nsd-control");

     

       800
       800
        
       

     

       801
       801
        
             controlCertFile = mkOption {

     

       802
       802
        
               type = types.path;

+1 -1

nixos/modules/services/networking/ntp/openntpd.nix

···

       19
       19
        
         ###### interface

     

       20
       20
        
       

     

       21
       21
        
         options.services.openntpd = {

     

       22
       22
       -
           enable = mkEnableOption "OpenNTP time synchronization server";

     

       22
       22
       +
           enable = mkEnableOption (lib.mdDoc "OpenNTP time synchronization server");

     

       23
       23
        
       

     

       24
       24
        
           servers = mkOption {

     

       25
       25
        
             default = config.services.ntp.servers;

+1 -1

nixos/modules/services/networking/nullidentdmod.nix

···

       3
       3
        
       

     

       4
       4
        
       in {

     

       5
       5
        
         options.services.nullidentdmod = with types; {

     

       6
       6
       -
           enable = mkEnableOption "the nullidentdmod identd daemon";

     

       6
       6
       +
           enable = mkEnableOption (lib.mdDoc "the nullidentdmod identd daemon");

     

       7
       7
        
       

     

       8
       8
        
           userid = mkOption {

     

       9
       9
        
             type = nullOr str;

+1 -1

nixos/modules/services/networking/ocserv.nix

···

       10
       10
        
       

     

       11
       11
        
       {

     

       12
       12
        
         options.services.ocserv = {

     

       13
       13
       -
           enable = mkEnableOption "ocserv";

     

       13
       13
       +
           enable = mkEnableOption (lib.mdDoc "ocserv");

     

       14
       14
        
       

     

       15
       15
        
           config = mkOption {

     

       16
       16
        
             type = types.lines;

+1 -1

nixos/modules/services/networking/ofono.nix

···

       19
       19
        
         ###### interface

     

       20
       20
        
         options = {

     

       21
       21
        
           services.ofono = {

     

       22
       22
       -
             enable = mkEnableOption "Ofono";

     

       22
       22
       +
             enable = mkEnableOption (lib.mdDoc "Ofono");

     

       23
       23
        
       

     

       24
       24
        
             plugins = mkOption {

     

       25
       25
        
               type = types.listOf types.package;

+1 -1

nixos/modules/services/networking/ostinato.nix

···

       26
       26
        
       

     

       27
       27
        
           services.ostinato = {

     

       28
       28
        
       

     

       29
       29
       -
             enable = mkEnableOption "Ostinato agent-controller (Drone)";

     

       29
       29
       +
             enable = mkEnableOption (lib.mdDoc "Ostinato agent-controller (Drone)");

     

       30
       30
        
       

     

       31
       31
        
             port = mkOption {

     

       32
       32
        
               type = types.int;

+1 -1

nixos/modules/services/networking/owamp.nix

···

       10
       10
        
         ###### interface

     

       11
       11
        
       

     

       12
       12
        
         options = {

     

       13
       13
       -
           services.owamp.enable = mkEnableOption "Enable OWAMP server";

     

       13
       13
       +
           services.owamp.enable = mkEnableOption (lib.mdDoc "Enable OWAMP server");

     

       14
       14
        
         };

     

       15
       15
        
       

     

       16
       16

+1 -1

nixos/modules/services/networking/pdns-recursor.nix

···

       27
       27
        
       

     

       28
       28
        
       in {

     

       29
       29
        
         options.services.pdns-recursor = {

     

       30
       30
       -
           enable = mkEnableOption "PowerDNS Recursor, a recursive DNS server";

     

       30
       30
       +
           enable = mkEnableOption (lib.mdDoc "PowerDNS Recursor, a recursive DNS server");

     

       31
       31
        
       

     

       32
       32
        
           dns.address = mkOption {

     

       33
       33
        
             type = oneOrMore types.str;

+1 -1

nixos/modules/services/networking/pdnsd.nix

···

       24
       24
        
       

     

       25
       25
        
       { options =

     

       26
       26
        
           { services.pdnsd =

     

       27
       27
       -
               { enable = mkEnableOption "pdnsd";

     

       27
       27
       +
               { enable = mkEnableOption (lib.mdDoc "pdnsd");

     

       28
       28
        
       

     

       29
       29
        
                 cacheDir = mkOption {

     

       30
       30
        
                   type = types.str;

+1 -1

nixos/modules/services/networking/pixiecore.nix

···

       10
       10
        
       

     

       11
       11
        
         options = {

     

       12
       12
        
           services.pixiecore = {

     

       13
       13
       -
             enable = mkEnableOption "Pixiecore";

     

       13
       13
       +
             enable = mkEnableOption (lib.mdDoc "Pixiecore");

     

       14
       14
        
       

     

       15
       15
        
             openFirewall = mkOption {

     

       16
       16
        
               type = types.bool;

+1 -1

nixos/modules/services/networking/pleroma.nix

···

       4
       4
        
       in {

     

       5
       5
        
         options = {

     

       6
       6
        
           services.pleroma = with lib; {

     

       7
       7
       -
             enable = mkEnableOption "pleroma";

     

       7
       7
       +
             enable = mkEnableOption (lib.mdDoc "pleroma");

     

       8
       8
        
       

     

       9
       9
        
             package = mkOption {

     

       10
       10
        
               type = types.package;

+1 -1

nixos/modules/services/networking/powerdns.nix

···

       8
       8
        
       in {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.powerdns = {

     

       11
       11
       -
             enable = mkEnableOption "PowerDNS domain name server";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "PowerDNS domain name server");

     

       12
       12
        
       

     

       13
       13
        
             extraConfig = mkOption {

     

       14
       14
        
               type = types.lines;

+1 -1

nixos/modules/services/networking/pppd.nix

···

       12
       12
        
       

     

       13
       13
        
         options = {

     

       14
       14
        
           services.pppd = {

     

       15
       15
       -
             enable = mkEnableOption "pppd";

     

       15
       15
       +
             enable = mkEnableOption (lib.mdDoc "pppd");

     

       16
       16
        
       

     

       17
       17
        
             package = mkOption {

     

       18
       18
        
               default = pkgs.ppp;

+1 -1

nixos/modules/services/networking/pptpd.nix

···

       5
       5
        
       {

     

       6
       6
        
         options = {

     

       7
       7
        
           services.pptpd = {

     

       8
       8
       -
             enable = mkEnableOption "pptpd, the Point-to-Point Tunneling Protocol daemon";

     

       8
       8
       +
             enable = mkEnableOption (lib.mdDoc "pptpd, the Point-to-Point Tunneling Protocol daemon");

     

       9
       9
        
       

     

       10
       10
        
             serverIp = mkOption {

     

       11
       11
        
               type        = types.str;

+1 -1

nixos/modules/services/networking/prayer.nix

···

       41
       41
        
       

     

       42
       42
        
           services.prayer = {

     

       43
       43
        
       

     

       44
       44
       -
             enable = mkEnableOption "the prayer webmail http server";

     

       44
       44
       +
             enable = mkEnableOption (lib.mdDoc "the prayer webmail http server");

     

       45
       45
        
       

     

       46
       46
        
             port = mkOption {

     

       47
       47
        
               default = 2080;

+1 -1

nixos/modules/services/networking/privoxy.nix

···

       53
       53
        
       

     

       54
       54
        
         options.services.privoxy = {

     

       55
       55
        
       

     

       56
       56
       -
           enable = mkEnableOption "Privoxy, non-caching filtering proxy";

     

       56
       56
       +
           enable = mkEnableOption (lib.mdDoc "Privoxy, non-caching filtering proxy");

     

       57
       57
        
       

     

       58
       58
        
           enableTor = mkOption {

     

       59
       59
        
             type = types.bool;

+1 -1

nixos/modules/services/networking/quassel.nix

···

       17
       17
        
       

     

       18
       18
        
           services.quassel = {

     

       19
       19
        
       

     

       20
       20
       -
             enable = mkEnableOption "the Quassel IRC client daemon";

     

       20
       20
       +
             enable = mkEnableOption (lib.mdDoc "the Quassel IRC client daemon");

     

       21
       21
        
       

     

       22
       22
        
             certificateFile = mkOption {

     

       23
       23
        
               type = types.nullOr types.str;

+1 -1

nixos/modules/services/networking/quorum.nix

···

       13
       13
        
         options = {

     

       14
       14
        
       

     

       15
       15
        
           services.quorum = {

     

       16
       16
       -
             enable = mkEnableOption "Quorum blockchain daemon";

     

       16
       16
       +
             enable = mkEnableOption (lib.mdDoc "Quorum blockchain daemon");

     

       17
       17
        
       

     

       18
       18
        
             user = mkOption {

     

       19
       19
        
               type = types.str;

+1 -1

nixos/modules/services/networking/r53-ddns.nix

···

       10
       10
        
         options = {

     

       11
       11
        
           services.r53-ddns = {

     

       12
       12
        
       

     

       13
       13
       -
             enable = mkEnableOption "r53-ddyns";

     

       13
       13
       +
             enable = mkEnableOption (lib.mdDoc "r53-ddyns");

     

       14
       14
        
       

     

       15
       15
        
             interval = mkOption {

     

       16
       16
        
               type = types.str;

+1 -1

nixos/modules/services/networking/radicale.nix

···

       25
       25
        
       

     

       26
       26
        
       in {

     

       27
       27
        
         options.services.radicale = {

     

       28
       28
       -
           enable = mkEnableOption "Radicale CalDAV and CardDAV server";

     

       28
       28
       +
           enable = mkEnableOption (lib.mdDoc "Radicale CalDAV and CardDAV server");

     

       29
       29
        
       

     

       30
       30
        
           package = mkOption {

     

       31
       31
        
             description = lib.mdDoc "Radicale package to use.";

+1 -1

nixos/modules/services/networking/robustirc-bridge.nix

···

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.robustirc-bridge = {

     

       11
       11
       -
             enable = mkEnableOption "RobustIRC bridge";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "RobustIRC bridge");

     

       12
       12
        
       

     

       13
       13
        
             extraFlags = mkOption {

     

       14
       14
        
               type = types.listOf types.str;

+1 -1

nixos/modules/services/networking/routedns.nix

···

       12
       12
        
       in

     

       13
       13
        
       {

     

       14
       14
        
         options.services.routedns = {

     

       15
       15
       -
           enable = mkEnableOption "RouteDNS - DNS stub resolver, proxy and router";

     

       15
       15
       +
           enable = mkEnableOption (lib.mdDoc "RouteDNS - DNS stub resolver, proxy and router");

     

       16
       16
        
       

     

       17
       17
        
           settings = mkOption {

     

       18
       18
        
             type = settingsFormat.type;

+3 -3

nixos/modules/services/networking/rxe.nix

···

       10
       10
        
       

     

       11
       11
        
         options = {

     

       12
       12
        
           networking.rxe = {

     

       13
       13
       -
             enable = mkEnableOption "RDMA over converged ethernet";

     

       13
       13
       +
             enable = mkEnableOption (lib.mdDoc "RDMA over converged ethernet");

     

       14
       14
        
             interfaces = mkOption {

     

       15
       15
        
               type = types.listOf types.str;

     

       16
       16
        
               default = [ ];

     

       17
       17
        
               example = [ "eth0" ];

     

       18
       18
       -
               description = ''

     

       18
       18
       +
               description = lib.mdDoc ''

     

       19
       19
        
                 Enable RDMA on the listed interfaces. The corresponding virtual

     

       20
       20
       -
                 RDMA interfaces will be named rxe_&lt;interface&gt;.

     

       20
       20
       +
                 RDMA interfaces will be named rxe_\<interface\>.

     

       21
       21
        
                 UDP port 4791 must be open on the respective ethernet interfaces.

     

       22
       22
        
               '';

     

       23
       23
        
             };

+1 -1

nixos/modules/services/networking/sabnzbd.nix

···

       15
       15
        
       

     

       16
       16
        
         options = {

     

       17
       17
        
           services.sabnzbd = {

     

       18
       18
       -
             enable = mkEnableOption "the sabnzbd server";

     

       18
       18
       +
             enable = mkEnableOption (lib.mdDoc "the sabnzbd server");

     

       19
       19
        
       

     

       20
       20
        
             package = mkOption {

     

       21
       21
        
               type = types.package;

+1 -1

nixos/modules/services/networking/seafile.nix

···

       37
       37
        
         ###### Interface

     

       38
       38
        
       

     

       39
       39
        
         options.services.seafile = {

     

       40
       40
       -
           enable = mkEnableOption "Seafile server";

     

       40
       40
       +
           enable = mkEnableOption (lib.mdDoc "Seafile server");

     

       41
       41
        
       

     

       42
       42
        
           ccnetSettings = mkOption {

     

       43
       43
        
             type = types.submodule {

+1 -1

nixos/modules/services/networking/shellhub-agent.nix

···

       12
       12
        
       

     

       13
       13
        
           services.shellhub-agent = {

     

       14
       14
        
       

     

       15
       15
       -
             enable = mkEnableOption "ShellHub Agent daemon";

     

       15
       15
       +
             enable = mkEnableOption (lib.mdDoc "ShellHub Agent daemon");

     

       16
       16
        
       

     

       17
       17
        
             package = mkPackageOption pkgs "shellhub-agent" { };

     

       18
       18

+1 -1

nixos/modules/services/networking/shout.nix

···

       23
       23
        
       

     

       24
       24
        
       in {

     

       25
       25
        
         options.services.shout = {

     

       26
       26
       -
           enable = mkEnableOption "Shout web IRC client";

     

       26
       26
       +
           enable = mkEnableOption (lib.mdDoc "Shout web IRC client");

     

       27
       27
        
       

     

       28
       28
        
           private = mkOption {

     

       29
       29
        
             type = types.bool;

+1 -1

nixos/modules/services/networking/skydns.nix

···

       7
       7
        
       

     

       8
       8
        
       in {

     

       9
       9
        
         options.services.skydns = {

     

       10
       10
       -
           enable = mkEnableOption "skydns service";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "skydns service");

     

       11
       11
        
       

     

       12
       12
        
           etcd = {

     

       13
       13
        
             machines = mkOption {

+1 -1

nixos/modules/services/networking/smartdns.nix

···

       20
       20
        
           } cfg.settings);

     

       21
       21
        
       in {

     

       22
       22
        
         options.services.smartdns = {

     

       23
       23
       -
           enable = mkEnableOption "SmartDNS DNS server";

     

       23
       23
       +
           enable = mkEnableOption (lib.mdDoc "SmartDNS DNS server");

     

       24
       24
        
       

     

       25
       25
        
           bindPort = mkOption {

     

       26
       26
        
             type = types.port;

+1 -1

nixos/modules/services/networking/sniproxy.nix

···

       18
       18
        
       

     

       19
       19
        
         options = {

     

       20
       20
        
           services.sniproxy = {

     

       21
       21
       -
             enable = mkEnableOption "sniproxy server";

     

       21
       21
       +
             enable = mkEnableOption (lib.mdDoc "sniproxy server");

     

       22
       22
        
       

     

       23
       23
        
             user = mkOption {

     

       24
       24
        
               type = types.str;

+1 -1

nixos/modules/services/networking/snowflake-proxy.nix

···

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.snowflake-proxy = {

     

       11
       11
       -
             enable = mkEnableOption "System to defeat internet censorship";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "System to defeat internet censorship");

     

       12
       12
        
       

     

       13
       13
        
             broker = mkOption {

     

       14
       14
        
               description = lib.mdDoc "Broker URL (default \"https://snowflake-broker.torproject.net/\")";

+4 -4

nixos/modules/services/networking/softether.nix

···

       16
       16
        
       

     

       17
       17
        
           services.softether = {

     

       18
       18
        
       

     

       19
       19
       -
             enable = mkEnableOption "SoftEther VPN services";

     

       19
       19
       +
             enable = mkEnableOption (lib.mdDoc "SoftEther VPN services");

     

       20
       20
        
       

     

       21
       21
        
             package = mkOption {

     

       22
       22
        
               type = types.package;

     
···

       27
       27
        
               '';

     

       28
       28
        
             };

     

       29
       29
        
       

     

       30
       30
       -
             vpnserver.enable = mkEnableOption "SoftEther VPN Server";

     

       30
       30
       +
             vpnserver.enable = mkEnableOption (lib.mdDoc "SoftEther VPN Server");

     

       31
       31
        
       

     

       32
       32
       -
             vpnbridge.enable = mkEnableOption "SoftEther VPN Bridge";

     

       32
       32
       +
             vpnbridge.enable = mkEnableOption (lib.mdDoc "SoftEther VPN Bridge");

     

       33
       33
        
       

     

       34
       34
        
             vpnclient = {

     

       35
       35
       -
               enable = mkEnableOption "SoftEther VPN Client";

     

       35
       35
       +
               enable = mkEnableOption (lib.mdDoc "SoftEther VPN Client");

     

       36
       36
        
               up = mkOption {

     

       37
       37
        
                 type = types.lines;

     

       38
       38
        
                 default = "";

+1 -1

nixos/modules/services/networking/soju.nix

···

       27
       27
        
         ###### interface

     

       28
       28
        
       

     

       29
       29
        
         options.services.soju = {

     

       30
       30
       -
           enable = mkEnableOption "soju";

     

       30
       30
       +
           enable = mkEnableOption (lib.mdDoc "soju");

     

       31
       31
        
       

     

       32
       32
        
           listen = mkOption {

     

       33
       33
        
             type = types.listOf types.str;

+1 -1

nixos/modules/services/networking/solanum.nix

···

       16
       16
        
       

     

       17
       17
        
           services.solanum = {

     

       18
       18
        
       

     

       19
       19
       -
             enable = mkEnableOption "Solanum IRC daemon";

     

       19
       19
       +
             enable = mkEnableOption (lib.mdDoc "Solanum IRC daemon");

     

       20
       20
        
       

     

       21
       21
        
             config = mkOption {

     

       22
       22
        
               type = types.str;

+2 -2

nixos/modules/services/networking/spacecookie.nix

···

       25
       25
        
       

     

       26
       26
        
           services.spacecookie = {

     

       27
       27
        
       

     

       28
       28
       -
             enable = mkEnableOption "spacecookie";

     

       28
       28
       +
             enable = mkEnableOption (lib.mdDoc "spacecookie");

     

       29
       29
        
       

     

       30
       30
        
             package = mkOption {

     

       31
       31
        
               type = types.package;

     
···

       90
       90
        
                 };

     

       91
       91
        
       

     

       92
       92
        
                 options.log = {

     

       93
       93
       -
                   enable = mkEnableOption "logging for spacecookie"

     

       93
       93
       +
                   enable = mkEnableOption (lib.mdDoc "logging for spacecookie")

     

       94
       94
        
                     // { default = true; example = false; };

     

       95
       95
        
       

     

       96
       96
        
                   hide-ips = mkOption {

+1 -1

nixos/modules/services/networking/sslh.nix

···

       43
       43
        
       

     

       44
       44
        
         options = {

     

       45
       45
        
           services.sslh = {

     

       46
       46
       -
             enable = mkEnableOption "sslh";

     

       46
       46
       +
             enable = mkEnableOption (lib.mdDoc "sslh");

     

       47
       47
        
       

     

       48
       48
        
             verbose = mkOption {

     

       49
       49
        
               type = types.bool;

+1 -1

nixos/modules/services/networking/strongswan-swanctl/module.nix

···

       8
       8
        
         swanctlParams = import ./swanctl-params.nix lib;

     

       9
       9
        
       in  {

     

       10
       10
        
         options.services.strongswan-swanctl = {

     

       11
       11
       -
           enable = mkEnableOption "strongswan-swanctl service";

     

       11
       11
       +
           enable = mkEnableOption (lib.mdDoc "strongswan-swanctl service");

     

       12
       12
        
       

     

       13
       13
        
           package = mkOption {

     

       14
       14
        
             type = types.package;

+1 -1

nixos/modules/services/networking/strongswan.nix

···

       51
       51
        
       in

     

       52
       52
        
       {

     

       53
       53
        
         options.services.strongswan = {

     

       54
       54
       -
           enable = mkEnableOption "strongSwan";

     

       54
       54
       +
           enable = mkEnableOption (lib.mdDoc "strongSwan");

     

       55
       55
        
       

     

       56
       56
        
           secrets = mkOption {

     

       57
       57
        
             type = types.listOf types.str;

+1 -1

nixos/modules/services/networking/stubby.nix

···

       23
       23
        
         options = {

     

       24
       24
        
           services.stubby = {

     

       25
       25
        
       

     

       26
       26
       -
             enable = mkEnableOption "Stubby DNS resolver";

     

       26
       26
       +
             enable = mkEnableOption (lib.mdDoc "Stubby DNS resolver");

     

       27
       27
        
       

     

       28
       28
        
             settings = mkOption {

     

       29
       29
        
               type = types.attrsOf settingsFormat.type;

+2 -2

nixos/modules/services/networking/supybot.nix

···

       67
       67
        
               type = types.functionTo (types.listOf types.package);

     

       68
       68
        
               default = p: [];

     

       69
       69
        
               defaultText = literalExpression "p: []";

     

       70
       70
       -
               description = ''

     

       70
       70
       +
               description = lib.mdDoc ''

     

       71
       71
        
                 Extra Python packages available to supybot plugins. The

     

       72
       72
        
                 value must be a function which receives the attrset defined

     

       73
       73
       -
                 in <varname>python3Packages</varname> as the sole argument.

     

       73
       73
       +
                 in {var}`python3Packages` as the sole argument.

     

       74
       74
        
               '';

     

       75
       75
        
               example = literalExpression "p: [ p.lxml p.requests ]";

     

       76
       76
        
             };

+1 -1

nixos/modules/services/networking/syncthing-relay.nix

···

       22
       22
        
         ###### interface

     

       23
       23
        
       

     

       24
       24
        
         options.services.syncthing.relay = {

     

       25
       25
       -
           enable = mkEnableOption "Syncthing relay service";

     

       25
       25
       +
           enable = mkEnableOption (lib.mdDoc "Syncthing relay service");

     

       26
       26
        
       

     

       27
       27
        
           listenAddress = mkOption {

     

       28
       28
        
             type = types.str;

+1 -1

nixos/modules/services/networking/syncthing.nix

···

       74
       74
        
           services.syncthing = {

     

       75
       75
        
       

     

       76
       76
        
             enable = mkEnableOption

     

       77
       77
       -
               "Syncthing, a self-hosted open-source alternative to Dropbox and Bittorrent Sync";

     

       77
       77
       +
               (lib.mdDoc "Syncthing, a self-hosted open-source alternative to Dropbox and Bittorrent Sync");

     

       78
       78
        
       

     

       79
       79
        
             cert = mkOption {

     

       80
       80
        
               type = types.nullOr types.str;

+1 -1

nixos/modules/services/networking/tailscale.nix

···

       12
       12
        
         meta.maintainers = with maintainers; [ danderson mbaillie twitchyliquid64 ];

     

       13
       13
        
       

     

       14
       14
        
         options.services.tailscale = {

     

       15
       15
       -
           enable = mkEnableOption "Tailscale client daemon";

     

       15
       15
       +
           enable = mkEnableOption (lib.mdDoc "Tailscale client daemon");

     

       16
       16
        
       

     

       17
       17
        
           port = mkOption {

     

       18
       18
        
             type = types.port;

+1 -1

nixos/modules/services/networking/tedicross.nix

···

       13
       13
        
       in {

     

       14
       14
        
         options = {

     

       15
       15
        
           services.tedicross = {

     

       16
       16
       -
             enable = mkEnableOption "the TediCross Telegram-Discord bridge service";

     

       16
       16
       +
             enable = mkEnableOption (lib.mdDoc "the TediCross Telegram-Discord bridge service");

     

       17
       17
        
       

     

       18
       18
        
             config = mkOption {

     

       19
       19
        
               type = types.attrs;

+6 -6

nixos/modules/services/networking/teleport.nix

···

       9
       9
        
       {

     

       10
       10
        
         options = {

     

       11
       11
        
           services.teleport = with lib.types; {

     

       12
       12
       -
             enable = mkEnableOption "the Teleport service";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "the Teleport service");

     

       13
       13
        
       

     

       14
       14
        
             settings = mkOption {

     

       15
       15
        
               type = settingsYaml.type;

     
···

       41
       41
        
               '';

     

       42
       42
        
             };

     

       43
       43
        
       

     

       44
       44
       -
             insecure.enable = mkEnableOption ''

     

       44
       44
       +
             insecure.enable = mkEnableOption (lib.mdDoc ''

     

       45
       45
        
               starting teleport in insecure mode.

     

       46
       46
        
       

     

       47
       47
        
               This is dangerous!

     
···

       49
       49
        
               Proceed with caution!

     

       50
       50
        
       

     

       51
       51
        
               Teleport starts with disabled certificate validation on Proxy Service, validation still occurs on Auth Service

     

       52
       52
       -
             '';

     

       52
       52
       +
             '');

     

       53
       53
        
       

     

       54
       54
        
             diag = {

     

       55
       55
       -
               enable = mkEnableOption ''

     

       55
       55
       +
               enable = mkEnableOption (lib.mdDoc ''

     

       56
       56
        
                 endpoints for monitoring purposes.

     

       57
       57
        
       

     

       58
       58
       -
                 See <link xlink:href="https://goteleport.com/docs/setup/admin/troubleshooting/#troubleshooting/"/>

     

       59
       59
       -
               '';

     

       58
       58
       +
                 See <https://goteleport.com/docs/setup/admin/troubleshooting/#troubleshooting/>

     

       59
       59
       +
               '');

     

       60
       60
        
       

     

       61
       61
        
               addr = mkOption {

     

       62
       62
        
                 type = str;

+1 -1

nixos/modules/services/networking/tetrd.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
        
       {

     

       4
       4
       -
         options.services.tetrd.enable = lib.mkEnableOption "tetrd";

     

       4
       4
       +
         options.services.tetrd.enable = lib.mkEnableOption (lib.mdDoc "tetrd");

     

       5
       5
        
       

     

       6
       6
        
         config = lib.mkIf config.services.tetrd.enable {

     

       7
       7
        
           environment = {

+1 -1

nixos/modules/services/networking/thelounge.nix

···

       23
       23
        
         imports = [ (mkRemovedOptionModule [ "services" "thelounge" "private" ] "The option was renamed to `services.thelounge.public` to follow upstream changes.") ];

     

       24
       24
        
       

     

       25
       25
        
         options.services.thelounge = {

     

       26
       26
       -
           enable = mkEnableOption "The Lounge web IRC client";

     

       26
       26
       +
           enable = mkEnableOption (lib.mdDoc "The Lounge web IRC client");

     

       27
       27
        
       

     

       28
       28
        
           public = mkOption {

     

       29
       29
        
             type = types.bool;

+1 -1

nixos/modules/services/networking/tox-node.nix

···

       28
       28
        
       

     

       29
       29
        
       in {

     

       30
       30
        
         options.services.tox-node = {

     

       31
       31
       -
           enable = mkEnableOption "Tox Node service";

     

       31
       31
       +
           enable = mkEnableOption (lib.mdDoc "Tox Node service");

     

       32
       32
        
       

     

       33
       33
        
           logType = mkOption {

     

       34
       34
        
             type = types.enum [ "Stderr" "Stdout" "Syslog" "None" ];

+1 -1

nixos/modules/services/networking/toxvpn.nix

···

       5
       5
        
       {

     

       6
       6
        
         options = {

     

       7
       7
        
           services.toxvpn = {

     

       8
       8
       -
             enable = mkEnableOption "toxvpn running on startup";

     

       8
       8
       +
             enable = mkEnableOption (lib.mdDoc "toxvpn running on startup");

     

       9
       9
        
       

     

       10
       10
        
             localip = mkOption {

     

       11
       11
        
               type        = types.str;

+1 -1

nixos/modules/services/networking/tvheadend.nix

···

       9
       9
        
       {

     

       10
       10
        
         options = {

     

       11
       11
        
           services.tvheadend = {

     

       12
       12
       -
             enable = mkEnableOption "Tvheadend";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "Tvheadend");

     

       13
       13
        
             httpPort = mkOption {

     

       14
       14
        
               type        = types.int;

     

       15
       15
        
               default     = 9981;

+1 -1

nixos/modules/services/networking/ucarp.nix

···

       28
       28
        
         );

     

       29
       29
        
       in {

     

       30
       30
        
         options.networking.ucarp = {

     

       31
       31
       -
           enable = mkEnableOption "ucarp, userspace implementation of CARP";

     

       31
       31
       +
           enable = mkEnableOption (lib.mdDoc "ucarp, userspace implementation of CARP");

     

       32
       32
        
       

     

       33
       33
        
           interface = mkOption {

     

       34
       34
        
             type = types.str;

+1 -1

nixos/modules/services/networking/unbound.nix

···

       40
       40
        
         options = {

     

       41
       41
        
           services.unbound = {

     

       42
       42
        
       

     

       43
       43
       -
             enable = mkEnableOption "Unbound domain name server";

     

       43
       43
       +
             enable = mkEnableOption (lib.mdDoc "Unbound domain name server");

     

       44
       44
        
       

     

       45
       45
        
             package = mkOption {

     

       46
       46
        
               type = types.package;

+1 -1

nixos/modules/services/networking/uptermd.nix

···

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.uptermd = {

     

       11
       11
       -
             enable = mkEnableOption "uptermd";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "uptermd");

     

       12
       12
        
       

     

       13
       13
        
             openFirewall = mkOption {

     

       14
       14
        
               type = types.bool;

+1 -1

nixos/modules/services/networking/vsftpd.nix

···

       150
       150
        
       

     

       151
       151
        
           services.vsftpd = {

     

       152
       152
        
       

     

       153
       153
       -
             enable = mkEnableOption "vsftpd";

     

       153
       153
       +
             enable = mkEnableOption (lib.mdDoc "vsftpd");

     

       154
       154
        
       

     

       155
       155
        
             userlist = mkOption {

     

       156
       156
        
               default = [];

+1 -1

nixos/modules/services/networking/wasabibackend.nix

···

       29
       29
        
         options = {

     

       30
       30
        
       

     

       31
       31
        
           services.wasabibackend = {

     

       32
       32
       -
             enable = mkEnableOption "Wasabi backend service";

     

       32
       32
       +
             enable = mkEnableOption (lib.mdDoc "Wasabi backend service");

     

       33
       33
        
       

     

       34
       34
        
             dataDir = mkOption {

     

       35
       35
        
               type = types.path;

+1 -1

nixos/modules/services/networking/wg-netmanager.nix

···

       9
       9
        
       

     

       10
       10
        
         options = {

     

       11
       11
        
           services.wg-netmanager = {

     

       12
       12
       -
             enable = mkEnableOption "Wireguard network manager";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "Wireguard network manager");

     

       13
       13
        
           };

     

       14
       14
        
         };

     

       15
       15

+1 -1

nixos/modules/services/networking/wpa_supplicant.nix

···

       164
       164
        
       in {

     

       165
       165
        
         options = {

     

       166
       166
        
           networking.wireless = {

     

       167
       167
       -
             enable = mkEnableOption "wpa_supplicant";

     

       167
       167
       +
             enable = mkEnableOption (lib.mdDoc "wpa_supplicant");

     

       168
       168
        
       

     

       169
       169
        
             interfaces = mkOption {

     

       170
       170
        
               type = types.listOf types.str;

+1 -1

nixos/modules/services/networking/xandikos.nix

···

       9
       9
        
       

     

       10
       10
        
         options = {

     

       11
       11
        
           services.xandikos = {

     

       12
       12
       -
             enable = mkEnableOption "Xandikos CalDAV and CardDAV server";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "Xandikos CalDAV and CardDAV server");

     

       13
       13
        
       

     

       14
       14
        
             package = mkOption {

     

       15
       15
        
               type = types.package;

+1 -1

nixos/modules/services/networking/xinetd.nix

···

       44
       44
        
       

     

       45
       45
        
         options = {

     

       46
       46
        
       

     

       47
       47
       -
           services.xinetd.enable = mkEnableOption "the xinetd super-server daemon";

     

       47
       47
       +
           services.xinetd.enable = mkEnableOption (lib.mdDoc "the xinetd super-server daemon");

     

       48
       48
        
       

     

       49
       49
        
           services.xinetd.extraDefaults = mkOption {

     

       50
       50
        
             default = "";

+1 -1

nixos/modules/services/networking/xl2tpd.nix

···

       5
       5
        
       {

     

       6
       6
        
         options = {

     

       7
       7
        
           services.xl2tpd = {

     

       8
       8
       -
             enable = mkEnableOption "xl2tpd, the Layer 2 Tunnelling Protocol Daemon";

     

       8
       8
       +
             enable = mkEnableOption (lib.mdDoc "xl2tpd, the Layer 2 Tunnelling Protocol Daemon");

     

       9
       9
        
       

     

       10
       10
        
             serverIp = mkOption {

     

       11
       11
        
               type        = types.str;

+1 -1

nixos/modules/services/networking/xrdp.nix

···

       42
       42
        
       

     

       43
       43
        
           services.xrdp = {

     

       44
       44
        
       

     

       45
       45
       -
             enable = mkEnableOption "xrdp, the Remote Desktop Protocol server";

     

       45
       45
       +
             enable = mkEnableOption (lib.mdDoc "xrdp, the Remote Desktop Protocol server");

     

       46
       46
        
       

     

       47
       47
        
             package = mkOption {

     

       48
       48
        
               type = types.package;

+3 -3

nixos/modules/services/networking/yggdrasil.nix

···

       17
       17
        
       

     

       18
       18
        
         options = with types; {

     

       19
       19
        
           services.yggdrasil = {

     

       20
       20
       -
             enable = mkEnableOption "the yggdrasil system service";

     

       20
       20
       +
             enable = mkEnableOption (lib.mdDoc "the yggdrasil system service");

     

       21
       21
        
       

     

       22
       22
        
             settings = mkOption {

     

       23
       23
        
               type = format.type;

     
···

       109
       109
        
               description = lib.mdDoc "Yggdrasil package to use.";

     

       110
       110
        
             };

     

       111
       111
        
       

     

       112
       112
       -
             persistentKeys = mkEnableOption ''

     

       112
       112
       +
             persistentKeys = mkEnableOption (lib.mdDoc ''

     

       113
       113
        
               If enabled then keys will be generated once and Yggdrasil

     

       114
       114
        
               will retain the same IPv6 address when the service is

     

       115
       115
        
               restarted. Keys are stored at ${keysPath}.

     

       116
       116
       -
             '';

     

       116
       116
       +
             '');

     

       117
       117
        
       

     

       118
       118
        
           };

     

       119
       119
        
         };

+1 -1

nixos/modules/services/networking/zerobin.nix

···

       12
       12
        
         {

     

       13
       13
        
           options = {

     

       14
       14
        
             services.zerobin = {

     

       15
       15
       -
               enable = mkEnableOption "0bin";

     

       15
       15
       +
               enable = mkEnableOption (lib.mdDoc "0bin");

     

       16
       16
        
       

     

       17
       17
        
               dataDir = mkOption {

     

       18
       18
        
                 type = types.str;

+1 -1

nixos/modules/services/networking/zeronet.nix

···

       17
       17
        
         };

     

       18
       18
        
       in with lib; {

     

       19
       19
        
         options.services.zeronet = {

     

       20
       20
       -
           enable = mkEnableOption "zeronet";

     

       20
       20
       +
           enable = mkEnableOption (lib.mdDoc "zeronet");

     

       21
       21
        
       

     

       22
       22
        
           package = mkOption {

     

       23
       23
        
             type = types.package;

+1 -1

nixos/modules/services/networking/zerotierone.nix

···

       6
       6
        
         cfg = config.services.zerotierone;

     

       7
       7
        
       in

     

       8
       8
        
       {

     

       9
       9
       -
         options.services.zerotierone.enable = mkEnableOption "ZeroTierOne";

     

       9
       9
       +
         options.services.zerotierone.enable = mkEnableOption (lib.mdDoc "ZeroTierOne");

     

       10
       10
        
       

     

       11
       11
        
         options.services.zerotierone.joinNetworks = mkOption {

     

       12
       12
        
           default = [];

+1 -1

nixos/modules/services/networking/znc/default.nix

···

       81
       81
        
       

     

       82
       82
        
         options = {

     

       83
       83
        
           services.znc = {

     

       84
       84
       -
             enable = mkEnableOption "ZNC";

     

       84
       84
       +
             enable = mkEnableOption (lib.mdDoc "ZNC");

     

       85
       85
        
       

     

       86
       86
        
             user = mkOption {

     

       87
       87
        
               default = "znc";

+1 -1

nixos/modules/services/search/elasticsearch-curator.nix

···

       37
       37
        
       

     

       38
       38
        
         options.services.elasticsearch-curator = {

     

       39
       39
        
       

     

       40
       40
       -
           enable = mkEnableOption "elasticsearch curator";

     

       40
       40
       +
           enable = mkEnableOption (lib.mdDoc "elasticsearch curator");

     

       41
       41
        
           interval = mkOption {

     

       42
       42
        
             description = lib.mdDoc "The frequency to run curator, a systemd.time such as 'hourly'";

     

       43
       43
        
             default = "hourly";

+4 -4

nixos/modules/services/search/kibana.nix

···

       32
       32
        
       

     

       33
       33
        
       in {

     

       34
       34
        
         options.services.kibana = {

     

       35
       35
       -
           enable = mkEnableOption "kibana service";

     

       35
       35
       +
           enable = mkEnableOption (lib.mdDoc "kibana service");

     

       36
       36
        
       

     

       37
       37
        
           listenAddress = mkOption {

     

       38
       38
        
             description = lib.mdDoc "Kibana listening host";

     
···

       122
       122
        
             };

     

       123
       123
        
       

     

       124
       124
        
             certificateAuthorities = mkOption {

     

       125
       125
       -
               description = ''

     

       125
       125
       +
               description = lib.mdDoc ''

     

       126
       126
        
                 CA files to auth against elasticsearch.

     

       127
       127
        
       

     

       128
       128
       -
                 Please use the <option>ca</option> option when using kibana &lt; 5.4

     

       128
       128
       +
                 Please use the {option}`ca` option when using kibana \< 5.4

     

       129
       129
        
                 because those old versions don't support setting multiple CA's.

     

       130
       130
        
       

     

       131
       131
       -
                 This defaults to the singleton list [ca] when the <option>ca</option> option is defined.

     

       131
       131
       +
                 This defaults to the singleton list [ca] when the {option}`ca` option is defined.

     

       132
       132
        
               '';

     

       133
       133
        
               default = if cfg.elasticsearch.ca == null then [] else [ca];

     

       134
       134
        
               defaultText = literalExpression ''

+1 -1

nixos/modules/services/search/meilisearch.nix

···

       16
       16
        
         ###### interface

     

       17
       17
        
       

     

       18
       18
        
         options.services.meilisearch = {

     

       19
       19
       -
           enable = mkEnableOption "MeiliSearch - a RESTful search API";

     

       19
       19
       +
           enable = mkEnableOption (lib.mdDoc "MeiliSearch - a RESTful search API");

     

       20
       20
        
       

     

       21
       21
        
           package = mkOption {

     

       22
       22
        
             description = lib.mdDoc "The package to use for meilisearch. Use this if you require specific features to be enabled. The default package has no features.";

+1 -1

nixos/modules/services/search/solr.nix

···

       11
       11
        
       {

     

       12
       12
        
         options = {

     

       13
       13
        
           services.solr = {

     

       14
       14
       -
             enable = mkEnableOption "Solr";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "Solr");

     

       15
       15
        
       

     

       16
       16
        
             package = mkOption {

     

       17
       17
        
               type = types.package;

+1 -1

nixos/modules/services/security/aesmd.nix

···

       19
       19
        
       in

     

       20
       20
        
       {

     

       21
       21
        
         options.services.aesmd = {

     

       22
       22
       -
           enable = mkEnableOption "Intel's Architectural Enclave Service Manager (AESM) for Intel SGX";

     

       22
       22
       +
           enable = mkEnableOption (lib.mdDoc "Intel's Architectural Enclave Service Manager (AESM) for Intel SGX");

     

       23
       23
        
           debug = mkOption {

     

       24
       24
        
             type = types.bool;

     

       25
       25
        
             default = false;

+1 -1

nixos/modules/services/security/certmgr.nix

···

       35
       35
        
       in

     

       36
       36
        
       {

     

       37
       37
        
         options.services.certmgr = {

     

       38
       38
       -
           enable = mkEnableOption "certmgr";

     

       38
       38
       +
           enable = mkEnableOption (lib.mdDoc "certmgr");

     

       39
       39
        
       

     

       40
       40
        
           package = mkOption {

     

       41
       41
        
             type = types.package;

+1 -1

nixos/modules/services/security/cfssl.nix

···

       6
       6
        
         cfg = config.services.cfssl;

     

       7
       7
        
       in {

     

       8
       8
        
         options.services.cfssl = {

     

       9
       9
       -
           enable = mkEnableOption "the CFSSL CA api-server";

     

       9
       9
       +
           enable = mkEnableOption (lib.mdDoc "the CFSSL CA api-server");

     

       10
       10
        
       

     

       11
       11
        
           dataDir = mkOption {

     

       12
       12
        
             default = "/var/lib/cfssl";

+2 -2

nixos/modules/services/security/clamav.nix

···

       26
       26
        
         options = {

     

       27
       27
        
           services.clamav = {

     

       28
       28
        
             daemon = {

     

       29
       29
       -
               enable = mkEnableOption "ClamAV clamd daemon";

     

       29
       29
       +
               enable = mkEnableOption (lib.mdDoc "ClamAV clamd daemon");

     

       30
       30
        
       

     

       31
       31
        
               settings = mkOption {

     

       32
       32
        
                 type = with types; attrsOf (oneOf [ bool int str (listOf str) ]);

     
···

       38
       38
        
               };

     

       39
       39
        
             };

     

       40
       40
        
             updater = {

     

       41
       41
       -
               enable = mkEnableOption "ClamAV freshclam updater";

     

       41
       41
       +
               enable = mkEnableOption (lib.mdDoc "ClamAV freshclam updater");

     

       42
       42
        
       

     

       43
       43
        
               frequency = mkOption {

     

       44
       44
        
                 type = types.int;

+2 -2

nixos/modules/services/security/fprintd.nix

···

       18
       18
        
       

     

       19
       19
        
           services.fprintd = {

     

       20
       20
        
       

     

       21
       21
       -
             enable = mkEnableOption "fprintd daemon and PAM module for fingerprint readers handling";

     

       21
       21
       +
             enable = mkEnableOption (lib.mdDoc "fprintd daemon and PAM module for fingerprint readers handling");

     

       22
       22
        
       

     

       23
       23
        
             package = mkOption {

     

       24
       24
        
               type = types.package;

     
···

       31
       31
        
       

     

       32
       32
        
             tod = {

     

       33
       33
        
       

     

       34
       34
       -
               enable = mkEnableOption "Touch OEM Drivers library support";

     

       34
       34
       +
               enable = mkEnableOption (lib.mdDoc "Touch OEM Drivers library support");

     

       35
       35
        
       

     

       36
       36
        
               driver = mkOption {

     

       37
       37
        
                 type = types.package;

+3 -3

nixos/modules/services/security/haka.nix

···

       55
       55
        
       

     

       56
       56
        
           services.haka = {

     

       57
       57
        
       

     

       58
       58
       -
             enable = mkEnableOption "Haka";

     

       58
       58
       +
             enable = mkEnableOption (lib.mdDoc "Haka");

     

       59
       59
        
       

     

       60
       60
        
             package = mkOption {

     

       61
       61
        
               default = pkgs.haka;

     
···

       103
       103
        
               description = lib.mdDoc "Whether to enable pcap";

     

       104
       104
        
             };

     

       105
       105
        
       

     

       106
       106
       -
             nfqueue = mkEnableOption "nfqueue";

     

       106
       106
       +
             nfqueue = mkEnableOption (lib.mdDoc "nfqueue");

     

       107
       107
        
       

     

       108
       108
       -
             dump.enable = mkEnableOption "dump";

     

       108
       108
       +
             dump.enable = mkEnableOption (lib.mdDoc "dump");

     

       109
       109
        
             dump.input  = mkOption {

     

       110
       110
        
               default = "/tmp/input.pcap";

     

       111
       111
        
               example = "/path/to/file.pcap";

+2 -2

nixos/modules/services/security/haveged.nix

···

       15
       15
        
       

     

       16
       16
        
           services.haveged = {

     

       17
       17
        
       

     

       18
       18
       -
             enable = mkEnableOption ''

     

       18
       18
       +
             enable = mkEnableOption (lib.mdDoc ''

     

       19
       19
        
               haveged entropy daemon, which refills /dev/random when low.

     

       20
       20
        
               NOTE: does nothing on kernels newer than 5.6.

     

       21
       21
       -
             '';

     

       21
       21
       +
             '');

     

       22
       22
        
             # source for the note https://github.com/jirka-h/haveged/issues/57

     

       23
       23
        
       

     

       24
       24
        
             refill_threshold = mkOption {

+1 -1

nixos/modules/services/security/hockeypuck.nix

···

       7
       7
        
         meta.maintainers = with lib.maintainers; [ etu ];

     

       8
       8
        
       

     

       9
       9
        
         options.services.hockeypuck = {

     

       10
       10
       -
           enable = lib.mkEnableOption "Hockeypuck OpenPGP Key Server";

     

       10
       10
       +
           enable = lib.mkEnableOption (lib.mdDoc "Hockeypuck OpenPGP Key Server");

     

       11
       11
        
       

     

       12
       12
        
           port = lib.mkOption {

     

       13
       13
        
             default = 11371;

+1 -1

nixos/modules/services/security/infnoise.nix

···

       7
       7
        
       in {

     

       8
       8
        
         options = {

     

       9
       9
        
           services.infnoise = {

     

       10
       10
       -
             enable = mkEnableOption "the Infinite Noise TRNG driver";

     

       10
       10
       +
             enable = mkEnableOption (lib.mdDoc "the Infinite Noise TRNG driver");

     

       11
       11
        
       

     

       12
       12
        
             fillDevRandom = mkOption {

     

       13
       13
        
               description = lib.mdDoc ''

+3 -3

nixos/modules/services/security/kanidm.nix

···

       53
       53
        
       in

     

       54
       54
        
       {

     

       55
       55
        
         options.services.kanidm = {

     

       56
       56
       -
           enableClient = lib.mkEnableOption "the Kanidm client";

     

       57
       57
       -
           enableServer = lib.mkEnableOption "the Kanidm server";

     

       58
       58
       -
           enablePam = lib.mkEnableOption "the Kanidm PAM and NSS integration.";

     

       56
       56
       +
           enableClient = lib.mkEnableOption (lib.mdDoc "the Kanidm client");

     

       57
       57
       +
           enableServer = lib.mkEnableOption (lib.mdDoc "the Kanidm server");

     

       58
       58
       +
           enablePam = lib.mkEnableOption (lib.mdDoc "the Kanidm PAM and NSS integration.");

     

       59
       59
        
       

     

       60
       60
        
           serverSettings = lib.mkOption {

     

       61
       61
        
             type = lib.types.submodule {

+1 -1

nixos/modules/services/security/munge.nix

···

       15
       15
        
         options = {

     

       16
       16
        
       

     

       17
       17
        
           services.munge = {

     

       18
       18
       -
             enable = mkEnableOption "munge service";

     

       18
       18
       +
             enable = mkEnableOption (lib.mdDoc "munge service");

     

       19
       19
        
       

     

       20
       20
        
             password = mkOption {

     

       21
       21
        
               default = "/etc/munge/munge.key";

+1 -1

nixos/modules/services/security/nginx-sso.nix

···

       8
       8
        
         configYml = pkgs.writeText "nginx-sso.yml" (builtins.toJSON cfg.configuration);

     

       9
       9
        
       in {

     

       10
       10
        
         options.services.nginx.sso = {

     

       11
       11
       -
           enable = mkEnableOption "nginx-sso service";

     

       11
       11
       +
           enable = mkEnableOption (lib.mdDoc "nginx-sso service");

     

       12
       12
        
       

     

       13
       13
        
           package = mkOption {

     

       14
       14
        
             type = types.package;

+1 -1

nixos/modules/services/security/oauth2_proxy.nix

···

       86
       86
        
       in

     

       87
       87
        
       {

     

       88
       88
        
         options.services.oauth2_proxy = {

     

       89
       89
       -
           enable = mkEnableOption "oauth2_proxy";

     

       89
       89
       +
           enable = mkEnableOption (lib.mdDoc "oauth2_proxy");

     

       90
       90
        
       

     

       91
       91
        
           package = mkOption {

     

       92
       92
        
             type = types.package;

+1 -1

nixos/modules/services/security/opensnitch.nix

···

       8
       8
        
       in {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.opensnitch = {

     

       11
       11
       -
             enable = mkEnableOption "Opensnitch application firewall";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "Opensnitch application firewall");

     

       12
       12
        
             settings = mkOption {

     

       13
       13
        
               type = types.submodule {

     

       14
       14
        
                 freeformType = format.type;

+1 -1

nixos/modules/services/security/pass-secret-service.nix

···

       7
       7
        
       in

     

       8
       8
        
       {

     

       9
       9
        
         options.services.passSecretService = {

     

       10
       10
       -
           enable = mkEnableOption "pass secret service";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "pass secret service");

     

       11
       11
        
       

     

       12
       12
        
           package = mkOption {

     

       13
       13
        
             type = types.package;

+2 -2

nixos/modules/services/security/privacyidea.nix

···

       66
       66
        
       {

     

       67
       67
        
         options = {

     

       68
       68
        
           services.privacyidea = {

     

       69
       69
       -
             enable = mkEnableOption "PrivacyIDEA";

     

       69
       69
       +
             enable = mkEnableOption (lib.mdDoc "PrivacyIDEA");

     

       70
       70
        
       

     

       71
       71
        
             environmentFile = mkOption {

     

       72
       72
        
               type = types.nullOr types.path;

     
···

       179
       179
        
             };

     

       180
       180
        
       

     

       181
       181
        
             ldap-proxy = {

     

       182
       182
       -
               enable = mkEnableOption "PrivacyIDEA LDAP Proxy";

     

       182
       182
       +
               enable = mkEnableOption (lib.mdDoc "PrivacyIDEA LDAP Proxy");

     

       183
       183
        
       

     

       184
       184
        
               configFile = mkOption {

     

       185
       185
        
                 type = types.nullOr types.path;

+2 -2

nixos/modules/services/security/sks.nix

···

       16
       16
        
       

     

       17
       17
        
           services.sks = {

     

       18
       18
        
       

     

       19
       19
       -
             enable = mkEnableOption ''

     

       19
       19
       +
             enable = mkEnableOption (lib.mdDoc ''

     

       20
       20
        
               SKS (synchronizing key server for OpenPGP) and start the database

     

       21
       21
        
               server. You need to create "''${dataDir}/dump/*.gpg" for the initial

     

       22
       22
       -
               import'';

     

       22
       22
       +
               import'');

     

       23
       23
        
       

     

       24
       24
        
             package = mkOption {

     

       25
       25
        
               default = pkgs.sks;

+1 -1

nixos/modules/services/security/sslmate-agent.nix

···

       10
       10
        
       

     

       11
       11
        
         options = {

     

       12
       12
        
           services.sslmate-agent = {

     

       13
       13
       -
             enable = mkEnableOption "sslmate-agent, a daemon for managing SSL/TLS certificates on a server";

     

       13
       13
       +
             enable = mkEnableOption (lib.mdDoc "sslmate-agent, a daemon for managing SSL/TLS certificates on a server");

     

       14
       14
        
           };

     

       15
       15
        
         };

     

       16
       16

+2 -2

nixos/modules/services/security/step-ca.nix

···

       8
       8
        
       

     

       9
       9
        
         options = {

     

       10
       10
        
           services.step-ca = {

     

       11
       11
       -
             enable = lib.mkEnableOption "the smallstep certificate authority server";

     

       12
       12
       -
             openFirewall = lib.mkEnableOption "opening the certificate authority server port";

     

       11
       11
       +
             enable = lib.mkEnableOption (lib.mdDoc "the smallstep certificate authority server");

     

       12
       12
       +
             openFirewall = lib.mkEnableOption (lib.mdDoc "opening the certificate authority server port");

     

       13
       13
        
             package = lib.mkOption {

     

       14
       14
        
               type = lib.types.package;

     

       15
       15
        
               default = pkgs.step-ca;

+11 -11

nixos/modules/services/security/tor.nix

···

       224
       224
        
       

     

       225
       225
        
         options = {

     

       226
       226
        
           services.tor = {

     

       227
       227
       -
             enable = mkEnableOption ''Tor daemon.

     

       227
       227
       +
             enable = mkEnableOption (lib.mdDoc ''Tor daemon.

     

       228
       228
        
               By default, the daemon is run without

     

       229
       229
       -
               relay, exit, bridge or client connectivity'';

     

       229
       229
       +
               relay, exit, bridge or client connectivity'');

     

       230
       230
        
       

     

       231
       231
       -
             openFirewall = mkEnableOption "opening of the relay port(s) in the firewall";

     

       231
       231
       +
             openFirewall = mkEnableOption (lib.mdDoc "opening of the relay port(s) in the firewall");

     

       232
       232
        
       

     

       233
       233
        
             package = mkOption {

     

       234
       234
        
               type = types.package;

     
···

       237
       237
        
               description = lib.mdDoc "Tor package to use.";

     

       238
       238
        
             };

     

       239
       239
        
       

     

       240
       240
       -
             enableGeoIP = mkEnableOption ''use of GeoIP databases.

     

       240
       240
       +
             enableGeoIP = mkEnableOption (lib.mdDoc ''use of GeoIP databases.

     

       241
       241
        
               Disabling this will disable by-country statistics for bridges and relays

     

       242
       242
       -
               and some client and third-party software functionality'' // { default = true; };

     

       242
       242
       +
               and some client and third-party software functionality'') // { default = true; };

     

       243
       243
        
       

     

       244
       244
       -
             controlSocket.enable = mkEnableOption ''control socket,

     

       245
       245
       -
               created in <literal>${runDir}/control</literal>'';

     

       244
       244
       +
             controlSocket.enable = mkEnableOption (lib.mdDoc ''control socket,

     

       245
       245
       +
               created in `${runDir}/control`'');

     

       246
       246
        
       

     

       247
       247
        
             client = {

     

       248
       248
       -
               enable = mkEnableOption ''the routing of application connections.

     

       249
       249
       -
                 You might want to disable this if you plan running a dedicated Tor relay'';

     

       248
       248
       +
               enable = mkEnableOption (lib.mdDoc ''the routing of application connections.

     

       249
       249
       +
                 You might want to disable this if you plan running a dedicated Tor relay'');

     

       250
       250
        
       

     

       251
       251
       -
               transparentProxy.enable = mkEnableOption "transparent proxy";

     

       252
       252
       -
               dns.enable = mkEnableOption "DNS resolver";

     

       251
       251
       +
               transparentProxy.enable = mkEnableOption (lib.mdDoc "transparent proxy");

     

       252
       252
       +
               dns.enable = mkEnableOption (lib.mdDoc "DNS resolver");

     

       253
       253
        
       

     

       254
       254
        
               socksListenAddress = mkOption {

     

       255
       255
        
                 type = optionSOCKSPort false;

+1 -1

nixos/modules/services/security/usbguard.nix

···

       39
       39
        
       

     

       40
       40
        
         options = {

     

       41
       41
        
           services.usbguard = {

     

       42
       42
       -
             enable = mkEnableOption "USBGuard daemon";

     

       42
       42
       +
             enable = mkEnableOption (lib.mdDoc "USBGuard daemon");

     

       43
       43
        
       

     

       44
       44
        
             package = mkOption {

     

       45
       45
        
               type = types.package;

+1 -1

nixos/modules/services/security/vault.nix

···

       43
       43
        
       {

     

       44
       44
        
         options = {

     

       45
       45
        
           services.vault = {

     

       46
       46
       -
             enable = mkEnableOption "Vault daemon";

     

       46
       46
       +
             enable = mkEnableOption (lib.mdDoc "Vault daemon");

     

       47
       47
        
       

     

       48
       48
        
             package = mkOption {

     

       49
       49
        
               type = types.package;

+1 -1

nixos/modules/services/security/vaultwarden/default.nix

···

       39
       39
        
         ];

     

       40
       40
        
       

     

       41
       41
        
         options.services.vaultwarden = with types; {

     

       42
       42
       -
           enable = mkEnableOption "vaultwarden";

     

       42
       42
       +
           enable = mkEnableOption (lib.mdDoc "vaultwarden");

     

       43
       43
        
       

     

       44
       44
        
           dbBackend = mkOption {

     

       45
       45
        
             type = enum [ "sqlite" "mysql" "postgresql" ];

+1 -1

nixos/modules/services/system/cachix-agent/default.nix

···

       8
       8
        
         meta.maintainers = [ lib.maintainers.domenkozar ];

     

       9
       9
        
       

     

       10
       10
        
         options.services.cachix-agent = {

     

       11
       11
       -
           enable = mkEnableOption "Cachix Deploy Agent: https://docs.cachix.org/deploy/";

     

       11
       11
       +
           enable = mkEnableOption (lib.mdDoc "Cachix Deploy Agent: https://docs.cachix.org/deploy/");

     

       12
       12
        
       

     

       13
       13
        
           name = mkOption {

     

       14
       14
        
             type = types.str;

+1 -1

nixos/modules/services/system/earlyoom.nix

···

       11
       11
        
       in

     

       12
       12
        
       {

     

       13
       13
        
         options.services.earlyoom = {

     

       14
       14
       -
           enable = mkEnableOption "Early out of memory killing";

     

       14
       14
       +
           enable = mkEnableOption (lib.mdDoc "Early out of memory killing");

     

       15
       15
        
       

     

       16
       16
        
           freeMemThreshold = mkOption {

     

       17
       17
        
             type = types.ints.between 1 100;

+1 -1

nixos/modules/services/system/kerberos/default.nix

···

       51
       51
        
         ###### interface

     

       52
       52
        
         options = {

     

       53
       53
        
           services.kerberos_server = {

     

       54
       54
       -
             enable = lib.mkEnableOption "the kerberos authentification server";

     

       54
       54
       +
             enable = lib.mkEnableOption (lib.mdDoc "the kerberos authentification server");

     

       55
       55
        
       

     

       56
       56
        
             realms = mkOption {

     

       57
       57
        
               type = types.attrsOf (types.submodule realm);

+2 -2

nixos/modules/services/system/nscd.nix

···

       30
       30
        
             user = mkOption {

     

       31
       31
        
               type = types.str;

     

       32
       32
        
               default = "nscd";

     

       33
       33
       -
               description = ''

     

       33
       33
       +
               description = lib.mdDoc ''

     

       34
       34
        
                 User account under which nscd runs.

     

       35
       35
        
               '';

     

       36
       36
        
             };

     
···

       38
       38
        
             group = mkOption {

     

       39
       39
        
               type = types.str;

     

       40
       40
        
               default = "nscd";

     

       41
       41
       -
               description = ''

     

       41
       41
       +
               description = lib.mdDoc ''

     

       42
       42
        
                 User group under which nscd runs.

     

       43
       43
        
               '';

     

       44
       44
        
             };

+1 -1

nixos/modules/services/system/saslauthd.nix

···

       16
       16
        
       

     

       17
       17
        
           services.saslauthd = {

     

       18
       18
        
       

     

       19
       19
       -
             enable = mkEnableOption "saslauthd, the Cyrus SASL authentication daemon";

     

       19
       19
       +
             enable = mkEnableOption (lib.mdDoc "saslauthd, the Cyrus SASL authentication daemon");

     

       20
       20
        
       

     

       21
       21
        
             package = mkOption {

     

       22
       22
        
               default = pkgs.cyrus_sasl.bin;

+1 -1

nixos/modules/services/system/self-deploy.nix

···

       23
       23
        
       in

     

       24
       24
        
       {

     

       25
       25
        
         options.services.self-deploy = {

     

       26
       26
       -
           enable = lib.mkEnableOption "self-deploy";

     

       26
       26
       +
           enable = lib.mkEnableOption (lib.mdDoc "self-deploy");

     

       27
       27
        
       

     

       28
       28
        
           nixFile = lib.mkOption {

     

       29
       29
        
             type = lib.types.path;

+2 -2

nixos/modules/services/torrent/deluge.nix

···

       37
       37
        
         options = {

     

       38
       38
        
           services = {

     

       39
       39
        
             deluge = {

     

       40
       40
       -
               enable = mkEnableOption "Deluge daemon";

     

       40
       40
       +
               enable = mkEnableOption (lib.mdDoc "Deluge daemon");

     

       41
       41
        
       

     

       42
       42
        
               openFilesLimit = mkOption {

     

       43
       43
        
                 default = openFilesLimit;

     
···

       157
       157
        
             };

     

       158
       158
        
       

     

       159
       159
        
             deluge.web = {

     

       160
       160
       -
               enable = mkEnableOption "Deluge Web daemon";

     

       160
       160
       +
               enable = mkEnableOption (lib.mdDoc "Deluge Web daemon");

     

       161
       161
        
       

     

       162
       162
        
               port = mkOption {

     

       163
       163
        
                 type = types.port;

+1 -1

nixos/modules/services/torrent/flexget.nix

···

       14
       14
        
       in {

     

       15
       15
        
         options = {

     

       16
       16
        
           services.flexget = {

     

       17
       17
       -
             enable = mkEnableOption "Run FlexGet Daemon";

     

       17
       17
       +
             enable = mkEnableOption (lib.mdDoc "Run FlexGet Daemon");

     

       18
       18
        
       

     

       19
       19
        
             user = mkOption {

     

       20
       20
        
               default = "deluge";

+1 -1

nixos/modules/services/torrent/magnetico.nix

···

       43
       43
        
         ###### interface

     

       44
       44
        
       

     

       45
       45
        
         options.services.magnetico = {

     

       46
       46
       -
           enable = mkEnableOption "Magnetico, Bittorrent DHT crawler";

     

       46
       46
       +
           enable = mkEnableOption (lib.mdDoc "Magnetico, Bittorrent DHT crawler");

     

       47
       47
        
       

     

       48
       48
        
           crawler.address = mkOption {

     

       49
       49
        
             type = types.str;

+1 -1

nixos/modules/services/torrent/opentracker.nix

···

       5
       5
        
         cfg = config.services.opentracker;

     

       6
       6
        
       in {

     

       7
       7
        
         options.services.opentracker = {

     

       8
       8
       -
           enable = mkEnableOption "opentracker";

     

       8
       8
       +
           enable = mkEnableOption (lib.mdDoc "opentracker");

     

       9
       9
        
       

     

       10
       10
        
           package = mkOption {

     

       11
       11
        
             type = types.package;

+1 -1

nixos/modules/services/torrent/rtorrent.nix

···

       9
       9
        
       

     

       10
       10
        
       in {

     

       11
       11
        
         options.services.rtorrent = {

     

       12
       12
       -
           enable = mkEnableOption "rtorrent";

     

       12
       12
       +
           enable = mkEnableOption (lib.mdDoc "rtorrent");

     

       13
       13
        
       

     

       14
       14
        
           dataDir = mkOption {

     

       15
       15
        
             type = types.str;

+2 -2

nixos/modules/services/torrent/transmission.nix

···

       233
       233
        
               '';

     

       234
       234
        
             };

     

       235
       235
        
       

     

       236
       236
       -
             openPeerPorts = mkEnableOption "opening of the peer port(s) in the firewall";

     

       236
       236
       +
             openPeerPorts = mkEnableOption (lib.mdDoc "opening of the peer port(s) in the firewall");

     

       237
       237
        
       

     

       238
       238
       -
             openRPCPort = mkEnableOption "opening of the RPC port in the firewall";

     

       238
       238
       +
             openRPCPort = mkEnableOption (lib.mdDoc "opening of the RPC port in the firewall");

     

       239
       239
        
       

     

       240
       240
        
             performanceNetParameters = mkEnableOption "performance tweaks" // {

     

       241
       241
        
               description = ''

+1 -1

nixos/modules/services/tracing/tempo.nix

···

       8
       8
        
         settingsFormat = pkgs.formats.yaml {};

     

       9
       9
        
       in {

     

       10
       10
        
         options.services.tempo = {

     

       11
       11
       -
           enable = mkEnableOption "Grafana Tempo";

     

       11
       11
       +
           enable = mkEnableOption (lib.mdDoc "Grafana Tempo");

     

       12
       12
        
       

     

       13
       13
        
           settings = mkOption {

     

       14
       14
        
             type = settingsFormat.type;

+1 -1

nixos/modules/services/video/epgstation/default.nix

···

       78
       78
        
         ];

     

       79
       79
        
       

     

       80
       80
        
         options.services.epgstation = {

     

       81
       81
       -
           enable = lib.mkEnableOption description;

     

       81
       81
       +
           enable = lib.mkEnableOption (lib.mdDoc description);

     

       82
       82
        
       

     

       83
       83
        
           package = lib.mkOption {

     

       84
       84
        
             default = pkgs.epgstation;

+1 -1

nixos/modules/services/video/mirakurun.nix

···

       24
       24
        
         {

     

       25
       25
        
           options = {

     

       26
       26
        
             services.mirakurun = {

     

       27
       27
       -
               enable = mkEnableOption "the Mirakurun DVR Tuner Server";

     

       27
       27
       +
               enable = mkEnableOption (lib.mdDoc "the Mirakurun DVR Tuner Server");

     

       28
       28
        
       

     

       29
       29
        
               port = mkOption {

     

       30
       30
        
                 type = with types; nullOr port;

+3 -3

nixos/modules/services/video/replay-sorcery.nix

···

       9
       9
        
       {

     

       10
       10
        
         options = with types; {

     

       11
       11
        
           services.replay-sorcery = {

     

       12
       12
       -
             enable = mkEnableOption "the ReplaySorcery service for instant-replays";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "the ReplaySorcery service for instant-replays");

     

       13
       13
        
       

     

       14
       14
       -
             enableSysAdminCapability = mkEnableOption ''

     

       14
       14
       +
             enableSysAdminCapability = mkEnableOption (lib.mdDoc ''

     

       15
       15
        
               the system admin capability to support hardware accelerated

     

       16
       16
        
               video capture. This is equivalent to running ReplaySorcery as

     

       17
       17
       -
               root, so use with caution'';

     

       17
       17
       +
               root, so use with caution'');

     

       18
       18
        
       

     

       19
       19
        
             autoStart = mkOption {

     

       20
       20
        
               type = bool;

+1 -1

nixos/modules/services/video/rtsp-simple-server.nix

···

       10
       10
        
       {

     

       11
       11
        
         options = {

     

       12
       12
        
           services.rtsp-simple-server = {

     

       13
       13
       -
             enable = mkEnableOption "RTSP Simple Server";

     

       13
       13
       +
             enable = mkEnableOption (lib.mdDoc "RTSP Simple Server");

     

       14
       14
        
       

     

       15
       15
        
             settings = mkOption {

     

       16
       16
        
               description = lib.mdDoc ''

+1 -1

nixos/modules/services/wayland/cage.nix

···

       5
       5
        
       let

     

       6
       6
        
         cfg = config.services.cage;

     

       7
       7
        
       in {

     

       8
       8
       -
         options.services.cage.enable = mkEnableOption "cage kiosk service";

     

       8
       8
       +
         options.services.cage.enable = mkEnableOption (lib.mdDoc "cage kiosk service");

     

       9
       9
        
       

     

       10
       10
        
         options.services.cage.user = mkOption {

     

       11
       11
        
           type = types.str;

+3 -3

nixos/modules/services/web-apps/atlassian/confluence.nix

···

       29
       29
        
       {

     

       30
       30
        
         options = {

     

       31
       31
        
           services.confluence = {

     

       32
       32
       -
             enable = mkEnableOption "Atlassian Confluence service";

     

       32
       32
       +
             enable = mkEnableOption (lib.mdDoc "Atlassian Confluence service");

     

       33
       33
        
       

     

       34
       34
        
             user = mkOption {

     

       35
       35
        
               type = types.str;

     
···

       69
       69
        
             };

     

       70
       70
        
       

     

       71
       71
        
             proxy = {

     

       72
       72
       -
               enable = mkEnableOption "proxy support";

     

       72
       72
       +
               enable = mkEnableOption (lib.mdDoc "proxy support");

     

       73
       73
        
       

     

       74
       74
        
               name = mkOption {

     

       75
       75
        
                 type = types.str;

     
···

       93
       93
        
             };

     

       94
       94
        
       

     

       95
       95
        
             sso = {

     

       96
       96
       -
               enable = mkEnableOption "SSO with Atlassian Crowd";

     

       96
       96
       +
               enable = mkEnableOption (lib.mdDoc "SSO with Atlassian Crowd");

     

       97
       97
        
       

     

       98
       98
        
               crowd = mkOption {

     

       99
       99
        
                 type = types.str;

+2 -2

nixos/modules/services/web-apps/atlassian/crowd.nix

···

       34
       34
        
       {

     

       35
       35
        
         options = {

     

       36
       36
        
           services.crowd = {

     

       37
       37
       -
             enable = mkEnableOption "Atlassian Crowd service";

     

       37
       37
       +
             enable = mkEnableOption (lib.mdDoc "Atlassian Crowd service");

     

       38
       38
        
       

     

       39
       39
        
             user = mkOption {

     

       40
       40
        
               type = types.str;

     
···

       86
       86
        
             };

     

       87
       87
        
       

     

       88
       88
        
             proxy = {

     

       89
       89
       -
               enable = mkEnableOption "reverse proxy support";

     

       89
       89
       +
               enable = mkEnableOption (lib.mdDoc "reverse proxy support");

     

       90
       90
        
       

     

       91
       91
        
               name = mkOption {

     

       92
       92
        
                 type = types.str;

+3 -3

nixos/modules/services/web-apps/atlassian/jira.nix

···

       29
       29
        
       {

     

       30
       30
        
         options = {

     

       31
       31
        
           services.jira = {

     

       32
       32
       -
             enable = mkEnableOption "Atlassian JIRA service";

     

       32
       32
       +
             enable = mkEnableOption (lib.mdDoc "Atlassian JIRA service");

     

       33
       33
        
       

     

       34
       34
        
             user = mkOption {

     

       35
       35
        
               type = types.str;

     
···

       69
       69
        
             };

     

       70
       70
        
       

     

       71
       71
        
             proxy = {

     

       72
       72
       -
               enable = mkEnableOption "reverse proxy support";

     

       72
       72
       +
               enable = mkEnableOption (lib.mdDoc "reverse proxy support");

     

       73
       73
        
       

     

       74
       74
        
               name = mkOption {

     

       75
       75
        
                 type = types.str;

     
···

       99
       99
        
             };

     

       100
       100
        
       

     

       101
       101
        
             sso = {

     

       102
       102
       -
               enable = mkEnableOption "SSO with Atlassian Crowd";

     

       102
       102
       +
               enable = mkEnableOption (lib.mdDoc "SSO with Atlassian Crowd");

     

       103
       103
        
       

     

       104
       104
        
               crowd = mkOption {

     

       105
       105
        
                 type = types.str;

+1 -1

nixos/modules/services/web-apps/baget.nix

···

       53
       53
        
       in

     

       54
       54
        
       {

     

       55
       55
        
         options.services.baget = {

     

       56
       56
       -
           enable = mkEnableOption "BaGet NuGet-compatible server";

     

       56
       56
       +
           enable = mkEnableOption (lib.mdDoc "BaGet NuGet-compatible server");

     

       57
       57
        
       

     

       58
       58
        
           apiKeyFile = mkOption {

     

       59
       59
        
             type = types.path;

+1 -1

nixos/modules/services/web-apps/bookstack.nix

···

       34
       34
        
       

     

       35
       35
        
         options.services.bookstack = {

     

       36
       36
        
       

     

       37
       37
       -
           enable = mkEnableOption "BookStack";

     

       37
       37
       +
           enable = mkEnableOption (lib.mdDoc "BookStack");

     

       38
       38
        
       

     

       39
       39
        
           user = mkOption {

     

       40
       40
        
             default = "bookstack";

+1 -1

nixos/modules/services/web-apps/calibre-web.nix

···

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.calibre-web = {

     

       11
       11
       -
             enable = mkEnableOption "Calibre-Web";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "Calibre-Web");

     

       12
       12
        
       

     

       13
       13
        
             listen = {

     

       14
       14
        
               ip = mkOption {

+1 -1

nixos/modules/services/web-apps/code-server.nix

···

       11
       11
        
         ###### interface

     

       12
       12
        
         options = {

     

       13
       13
        
           services.code-server = {

     

       14
       14
       -
             enable = mkEnableOption "code-server";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "code-server");

     

       15
       15
        
       

     

       16
       16
        
             package = mkOption {

     

       17
       17
        
               default = pkgs.code-server;

+1 -1

nixos/modules/services/web-apps/convos.nix

···

       7
       7
        
       in

     

       8
       8
        
       {

     

       9
       9
        
         options.services.convos = {

     

       10
       10
       -
           enable = mkEnableOption "Convos";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "Convos");

     

       11
       11
        
           listenPort = mkOption {

     

       12
       12
        
             type = types.port;

     

       13
       13
        
             default = 3000;

+3 -3

nixos/modules/services/web-apps/dex.nix

···

       19
       19
        
       in

     

       20
       20
        
       {

     

       21
       21
        
         options.services.dex = {

     

       22
       22
       -
           enable = mkEnableOption "the OpenID Connect and OAuth2 identity provider";

     

       22
       22
       +
           enable = mkEnableOption (lib.mdDoc "the OpenID Connect and OAuth2 identity provider");

     

       23
       23
        
       

     

       24
       24
        
           environmentFile = mkOption {

     

       25
       25
        
             type = types.nullOr types.path;

     

       26
       26
        
             default = null;

     

       27
       27
       -
             description = ''

     

       28
       28
       -
               Environment file (see <literal>systemd.exec(5)</literal>

     

       27
       27
       +
             description = lib.mdDoc ''

     

       28
       28
       +
               Environment file (see `systemd.exec(5)`

     

       29
       29
        
               "EnvironmentFile=" section for the syntax) to define variables for dex.

     

       30
       30
        
               This option can be used to safely include secret keys into the dex configuration.

     

       31
       31
        
             '';

+1 -1

nixos/modules/services/web-apps/discourse.nix

···

       26
       26
        
       {

     

       27
       27
        
         options = {

     

       28
       28
        
           services.discourse = {

     

       29
       29
       -
             enable = lib.mkEnableOption "Discourse, an open source discussion platform";

     

       29
       29
       +
             enable = lib.mkEnableOption (lib.mdDoc "Discourse, an open source discussion platform");

     

       30
       30
        
       

     

       31
       31
        
             package = lib.mkOption {

     

       32
       32
        
               type = lib.types.package;

+1 -1

nixos/modules/services/web-apps/documize.nix

···

       12
       12
        
       

     

       13
       13
        
       in {

     

       14
       14
        
         options.services.documize = {

     

       15
       15
       -
           enable = mkEnableOption "Documize Wiki";

     

       15
       15
       +
           enable = mkEnableOption (lib.mdDoc "Documize Wiki");

     

       16
       16
        
       

     

       17
       17
        
           stateDirectoryName = mkOption {

     

       18
       18
        
             type = types.str;

+1 -1

nixos/modules/services/web-apps/dokuwiki.nix

···

       60
       60
        
         siteOpts = { config, lib, name, ... }:

     

       61
       61
        
           {

     

       62
       62
        
             options = {

     

       63
       63
       -
               enable = mkEnableOption "DokuWiki web application.";

     

       63
       63
       +
               enable = mkEnableOption (lib.mdDoc "DokuWiki web application.");

     

       64
       64
        
       

     

       65
       65
        
               package = mkOption {

     

       66
       66
        
                 type = types.package;

+1 -1

nixos/modules/services/web-apps/fluidd.nix

···

       6
       6
        
       in

     

       7
       7
        
       {

     

       8
       8
        
         options.services.fluidd = {

     

       9
       9
       -
           enable = mkEnableOption "Fluidd, a Klipper web interface for managing your 3d printer";

     

       9
       9
       +
           enable = mkEnableOption (lib.mdDoc "Fluidd, a Klipper web interface for managing your 3d printer");

     

       10
       10
        
       

     

       11
       11
        
           package = mkOption {

     

       12
       12
        
             type = types.package;

+1 -1

nixos/modules/services/web-apps/galene.nix

···

       12
       12
        
       {

     

       13
       13
        
         options = {

     

       14
       14
        
           services.galene = {

     

       15
       15
       -
             enable = mkEnableOption "Galene Service.";

     

       15
       15
       +
             enable = mkEnableOption (lib.mdDoc "Galene Service.");

     

       16
       16
        
       

     

       17
       17
        
             stateDir = mkOption {

     

       18
       18
        
               default = defaultstateDir;

+1 -1

nixos/modules/services/web-apps/gerrit.nix

···

       59
       59
        
       {

     

       60
       60
        
         options = {

     

       61
       61
        
           services.gerrit = {

     

       62
       62
       -
             enable = mkEnableOption "Gerrit service";

     

       62
       62
       +
             enable = mkEnableOption (lib.mdDoc "Gerrit service");

     

       63
       63
        
       

     

       64
       64
        
             package = mkOption {

     

       65
       65
        
               type = types.package;

+1 -1

nixos/modules/services/web-apps/gotify-server.nix

···

       7
       7
        
       in {

     

       8
       8
        
         options = {

     

       9
       9
        
           services.gotify = {

     

       10
       10
       -
             enable = mkEnableOption "Gotify webserver";

     

       10
       10
       +
             enable = mkEnableOption (lib.mdDoc "Gotify webserver");

     

       11
       11
        
       

     

       12
       12
        
             port = mkOption {

     

       13
       13
        
               type = types.port;

+1 -1

nixos/modules/services/web-apps/grocy.nix

···

       6
       6
        
         cfg = config.services.grocy;

     

       7
       7
        
       in {

     

       8
       8
        
         options.services.grocy = {

     

       9
       9
       -
           enable = mkEnableOption "grocy";

     

       9
       9
       +
           enable = mkEnableOption (lib.mdDoc "grocy");

     

       10
       10
        
       

     

       11
       11
        
           hostName = mkOption {

     

       12
       12
        
             type = types.str;

+2 -2

nixos/modules/services/web-apps/hedgedoc.nix

···

       32
       32
        
         ];

     

       33
       33
        
       

     

       34
       34
        
         options.services.hedgedoc = {

     

       35
       35
       -
           enable = mkEnableOption "the HedgeDoc Markdown Editor";

     

       35
       35
       +
           enable = mkEnableOption (lib.mdDoc "the HedgeDoc Markdown Editor");

     

       36
       36
        
       

     

       37
       37
        
           groups = mkOption {

     

       38
       38
        
             type = types.listOf types.str;

     
···

       51
       51
        
           };

     

       52
       52
        
       

     

       53
       53
        
           settings = let options = {

     

       54
       54
       -
             debug = mkEnableOption "debug mode";

     

       54
       54
       +
             debug = mkEnableOption (lib.mdDoc "debug mode");

     

       55
       55
        
             domain = mkOption {

     

       56
       56
        
               type = types.nullOr types.str;

     

       57
       57
        
               default = null;

+2 -2

nixos/modules/services/web-apps/hledger-web.nix

···

       5
       5
        
       in {

     

       6
       6
        
         options.services.hledger-web = {

     

       7
       7
        
       

     

       8
       8
       -
           enable = mkEnableOption "hledger-web service";

     

       8
       8
       +
           enable = mkEnableOption (lib.mdDoc "hledger-web service");

     

       9
       9
        
       

     

       10
       10
       -
           serveApi = mkEnableOption "Serve only the JSON web API, without the web UI.";

     

       10
       10
       +
           serveApi = mkEnableOption (lib.mdDoc "Serve only the JSON web API, without the web UI.");

     

       11
       11
        
       

     

       12
       12
        
           host = mkOption {

     

       13
       13
        
             type = types.str;

+6 -6

nixos/modules/services/web-apps/icingaweb2/icingaweb2.nix

···

       12
       12
        
         meta.maintainers = with maintainers; [ das_j ];

     

       13
       13
        
       

     

       14
       14
        
         options.services.icingaweb2 = with types; {

     

       15
       15
       -
           enable = mkEnableOption "the icingaweb2 web interface";

     

       15
       15
       +
           enable = mkEnableOption (lib.mdDoc "the icingaweb2 web interface");

     

       16
       16
        
       

     

       17
       17
        
           pool = mkOption {

     

       18
       18
        
             type = str;

     
···

       49
       49
        
           };

     

       50
       50
        
       

     

       51
       51
        
           modules = {

     

       52
       52
       -
             doc.enable = mkEnableOption "the icingaweb2 doc module";

     

       53
       53
       -
             migrate.enable = mkEnableOption "the icingaweb2 migrate module";

     

       54
       54
       -
             setup.enable = mkEnableOption "the icingaweb2 setup module";

     

       55
       55
       -
             test.enable = mkEnableOption "the icingaweb2 test module";

     

       56
       56
       -
             translation.enable = mkEnableOption "the icingaweb2 translation module";

     

       52
       52
       +
             doc.enable = mkEnableOption (lib.mdDoc "the icingaweb2 doc module");

     

       53
       53
       +
             migrate.enable = mkEnableOption (lib.mdDoc "the icingaweb2 migrate module");

     

       54
       54
       +
             setup.enable = mkEnableOption (lib.mdDoc "the icingaweb2 setup module");

     

       55
       55
       +
             test.enable = mkEnableOption (lib.mdDoc "the icingaweb2 test module");

     

       56
       56
       +
             translation.enable = mkEnableOption (lib.mdDoc "the icingaweb2 translation module");

     

       57
       57
        
           };

     

       58
       58
        
       

     

       59
       59
        
           modulePackages = mkOption {

+5 -5

nixos/modules/services/web-apps/ihatemoney/default.nix

···

       47
       47
        
       in

     

       48
       48
        
         {

     

       49
       49
        
           options.services.ihatemoney = {

     

       50
       50
       -
             enable = mkEnableOption "ihatemoney webapp. Note that this will set uwsgi to emperor mode";

     

       50
       50
       +
             enable = mkEnableOption (lib.mdDoc "ihatemoney webapp. Note that this will set uwsgi to emperor mode");

     

       51
       51
        
             backend = mkOption {

     

       52
       52
        
               type = types.enum [ "sqlite" "postgresql" ];

     

       53
       53
        
               default = "sqlite";

     
···

       88
       88
        
               default = true;

     

       89
       89
        
               description = lib.mdDoc "Use secure cookies. Disable this when ihatemoney is served via http instead of https";

     

       90
       90
        
             };

     

       91
       91
       -
             enableDemoProject = mkEnableOption "access to the demo project in ihatemoney";

     

       92
       92
       -
             enablePublicProjectCreation = mkEnableOption "permission to create projects in ihatemoney by anyone";

     

       93
       93
       -
             enableAdminDashboard = mkEnableOption "ihatemoney admin dashboard";

     

       94
       94
       -
             enableCaptcha = mkEnableOption "a simplistic captcha for some forms";

     

       91
       91
       +
             enableDemoProject = mkEnableOption (lib.mdDoc "access to the demo project in ihatemoney");

     

       92
       92
       +
             enablePublicProjectCreation = mkEnableOption (lib.mdDoc "permission to create projects in ihatemoney by anyone");

     

       93
       93
       +
             enableAdminDashboard = mkEnableOption (lib.mdDoc "ihatemoney admin dashboard");

     

       94
       94
       +
             enableCaptcha = mkEnableOption (lib.mdDoc "a simplistic captcha for some forms");

     

       95
       95
        
             legalLink = mkOption {

     

       96
       96
        
               type = types.nullOr types.str;

     

       97
       97
        
               default = null;

+1 -1

nixos/modules/services/web-apps/invidious.nix

···

       146
       146
        
       in

     

       147
       147
        
       {

     

       148
       148
        
         options.services.invidious = {

     

       149
       149
       -
           enable = lib.mkEnableOption "Invidious";

     

       149
       149
       +
           enable = lib.mkEnableOption (lib.mdDoc "Invidious");

     

       150
       150
        
       

     

       151
       151
        
           package = lib.mkOption {

     

       152
       152
        
             type = types.package;

+1 -1

nixos/modules/services/web-apps/invoiceplane.nix

···

       67
       67
        
           {

     

       68
       68
        
             options = {

     

       69
       69
        
       

     

       70
       70
       -
               enable = mkEnableOption "InvoicePlane web application";

     

       70
       70
       +
               enable = mkEnableOption (lib.mdDoc "InvoicePlane web application");

     

       71
       71
        
       

     

       72
       72
        
               stateDir = mkOption {

     

       73
       73
        
                 type = types.path;

+2 -2

nixos/modules/services/web-apps/isso.nix

···

       11
       11
        
       

     

       12
       12
        
         options = {

     

       13
       13
        
           services.isso = {

     

       14
       14
       -
             enable = mkEnableOption ''

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc ''

     

       15
       15
        
               A commenting server similar to Disqus.

     

       16
       16
        
       

     

       17
       17
        
               Note: The application's author suppose to run isso behind a reverse proxy.

     

       18
       18
        
               The embedded solution offered by NixOS is also only suitable for small installations

     

       19
       19
        
               below 20 requests per second.

     

       20
       20
       -
             '';

     

       20
       20
       +
             '');

     

       21
       21
        
       

     

       22
       22
        
             settings = mkOption {

     

       23
       23
        
               description = lib.mdDoc ''

+1 -1

nixos/modules/services/web-apps/jirafeau.nix

···

       36
       36
        
             description = lib.mdDoc "Location of Jirafeau storage directory.";

     

       37
       37
        
           };

     

       38
       38
        
       

     

       39
       39
       -
           enable = mkEnableOption "Jirafeau file upload application.";

     

       39
       39
       +
           enable = mkEnableOption (lib.mdDoc "Jirafeau file upload application.");

     

       40
       40
        
       

     

       41
       41
        
           extraConfig = mkOption {

     

       42
       42
        
             type = types.lines;

+2 -2

nixos/modules/services/web-apps/jitsi-meet.nix

···

       46
       46
        
       in

     

       47
       47
        
       {

     

       48
       48
        
         options.services.jitsi-meet = with types; {

     

       49
       49
       -
           enable = mkEnableOption "Jitsi Meet - Secure, Simple and Scalable Video Conferences";

     

       49
       49
       +
           enable = mkEnableOption (lib.mdDoc "Jitsi Meet - Secure, Simple and Scalable Video Conferences");

     

       50
       50
        
       

     

       51
       51
        
           hostName = mkOption {

     

       52
       52
        
             type = str;

     
···

       159
       159
        
             '';

     

       160
       160
        
           };

     

       161
       161
        
       

     

       162
       162
       -
           caddy.enable = mkEnableOption "Whether to enable caddy reverse proxy to expose jitsi-meet";

     

       162
       162
       +
           caddy.enable = mkEnableOption (lib.mdDoc "Whether to enable caddy reverse proxy to expose jitsi-meet");

     

       163
       163
        
       

     

       164
       164
        
           prosody.enable = mkOption {

     

       165
       165
        
             type = bool;

+1 -1

nixos/modules/services/web-apps/komga.nix

···

       8
       8
        
       in {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.komga = {

     

       11
       11
       -
             enable = mkEnableOption "Komga, a free and open source comics/mangas media server";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "Komga, a free and open source comics/mangas media server");

     

       12
       12
        
       

     

       13
       13
        
             port = mkOption {

     

       14
       14
        
               type = types.port;

+4 -4

nixos/modules/services/web-apps/lemmy.nix

···

       12
       12
        
       

     

       13
       13
        
         options.services.lemmy = {

     

       14
       14
        
       

     

       15
       15
       -
           enable = mkEnableOption "lemmy a federated alternative to reddit in rust";

     

       15
       15
       +
           enable = mkEnableOption (lib.mdDoc "lemmy a federated alternative to reddit in rust");

     

       16
       16
        
       

     

       17
       17
        
           jwtSecretPath = mkOption {

     

       18
       18
        
             type = types.path;

     
···

       27
       27
        
             };

     

       28
       28
        
           };

     

       29
       29
        
       

     

       30
       30
       -
           caddy.enable = mkEnableOption "exposing lemmy with the caddy reverse proxy";

     

       30
       30
       +
           caddy.enable = mkEnableOption (lib.mdDoc "exposing lemmy with the caddy reverse proxy");

     

       31
       31
        
       

     

       32
       32
        
           settings = mkOption {

     

       33
       33
        
             default = { };

     
···

       49
       49
        
               };

     

       50
       50
        
       

     

       51
       51
        
               options.federation = {

     

       52
       52
       -
                 enabled = mkEnableOption "activitypub federation";

     

       52
       52
       +
                 enabled = mkEnableOption (lib.mdDoc "activitypub federation");

     

       53
       53
        
               };

     

       54
       54
        
       

     

       55
       55
        
               options.captcha = {

     
···

       65
       65
        
                 };

     

       66
       66
        
               };

     

       67
       67
        
       

     

       68
       68
       -
               options.database.createLocally = mkEnableOption "creation of database on the instance";

     

       68
       68
       +
               options.database.createLocally = mkEnableOption (lib.mdDoc "creation of database on the instance");

     

       69
       69
        
       

     

       70
       70
        
             };

     

       71
       71
        
           };

+1 -1

nixos/modules/services/web-apps/limesurvey.nix

···

       32
       32
        
         # interface

     

       33
       33
        
       

     

       34
       34
        
         options.services.limesurvey = {

     

       35
       35
       -
           enable = mkEnableOption "Limesurvey web application.";

     

       35
       35
       +
           enable = mkEnableOption (lib.mdDoc "Limesurvey web application.");

     

       36
       36
        
       

     

       37
       37
        
           database = {

     

       38
       38
        
             type = mkOption {

+1 -1

nixos/modules/services/web-apps/mastodon.nix

···

       104
       104
        
       

     

       105
       105
        
         options = {

     

       106
       106
        
           services.mastodon = {

     

       107
       107
       -
             enable = lib.mkEnableOption "Mastodon, a federated social network server";

     

       107
       107
       +
             enable = lib.mkEnableOption (lib.mdDoc "Mastodon, a federated social network server");

     

       108
       108
        
       

     

       109
       109
        
             configureNginx = lib.mkOption {

     

       110
       110
        
               description = ''

+2 -2

nixos/modules/services/web-apps/mattermost.nix

···

       101
       101
        
       {

     

       102
       102
        
         options = {

     

       103
       103
        
           services.mattermost = {

     

       104
       104
       -
             enable = mkEnableOption "Mattermost chat server";

     

       104
       104
       +
             enable = mkEnableOption (lib.mdDoc "Mattermost chat server");

     

       105
       105
        
       

     

       106
       106
        
             package = mkOption {

     

       107
       107
        
               type = types.package;

     
···

       234
       234
        
             };

     

       235
       235
        
       

     

       236
       236
        
             matterircd = {

     

       237
       237
       -
               enable = mkEnableOption "Mattermost IRC bridge";

     

       237
       237
       +
               enable = mkEnableOption (lib.mdDoc "Mattermost IRC bridge");

     

       238
       238
        
               package = mkOption {

     

       239
       239
        
                 type = types.package;

     

       240
       240
        
                 default = pkgs.matterircd;

+1 -1

nixos/modules/services/web-apps/mediawiki.nix

···

       171
       171
        
         options = {

     

       172
       172
        
           services.mediawiki = {

     

       173
       173
        
       

     

       174
       174
       -
             enable = mkEnableOption "MediaWiki";

     

       174
       174
       +
             enable = mkEnableOption (lib.mdDoc "MediaWiki");

     

       175
       175
        
       

     

       176
       176
        
             package = mkOption {

     

       177
       177
        
               type = types.package;

+1 -1

nixos/modules/services/web-apps/miniflux.nix

···

       19
       19
        
       {

     

       20
       20
        
         options = {

     

       21
       21
        
           services.miniflux = {

     

       22
       22
       -
             enable = mkEnableOption "miniflux and creates a local postgres database for it";

     

       22
       22
       +
             enable = mkEnableOption (lib.mdDoc "miniflux and creates a local postgres database for it");

     

       23
       23
        
       

     

       24
       24
        
             config = mkOption {

     

       25
       25
        
               type = types.attrsOf types.str;

+1 -1

nixos/modules/services/web-apps/moodle.nix

···

       62
       62
        
       {

     

       63
       63
        
         # interface

     

       64
       64
        
         options.services.moodle = {

     

       65
       65
       -
           enable = mkEnableOption "Moodle web application";

     

       65
       65
       +
           enable = mkEnableOption (lib.mdDoc "Moodle web application");

     

       66
       66
        
       

     

       67
       67
        
           package = mkOption {

     

       68
       68
        
             type = types.package;

+7 -7

nixos/modules/services/web-apps/nextcloud.nix

···

       79
       79
        
         ];

     

       80
       80
        
       

     

       81
       81
        
         options.services.nextcloud = {

     

       82
       82
       -
           enable = mkEnableOption "nextcloud";

     

       82
       82
       +
           enable = mkEnableOption (lib.mdDoc "nextcloud");

     

       83
       83
        
           hostName = mkOption {

     

       84
       84
        
             type = types.str;

     

       85
       85
        
             description = lib.mdDoc "FQDN for the nextcloud instance.";

     
···

       387
       387
        
       

     

       388
       388
        
             objectstore = {

     

       389
       389
        
               s3 = {

     

       390
       390
       -
                 enable = mkEnableOption ''

     

       390
       390
       +
                 enable = mkEnableOption (lib.mdDoc ''

     

       391
       391
        
                   S3 object storage as primary storage.

     

       392
       392
        
       

     

       393
       393
        
                   This mounts a bucket on an Amazon S3 object storage or compatible

     

       394
       394
        
                   implementation into the virtual filesystem.

     

       395
       395
        
       

     

       396
       396
        
                   Further details about this feature can be found in the

     

       397
       397
       -
                   <link xlink:href="https://docs.nextcloud.com/server/22/admin_manual/configuration_files/primary_storage.html">upstream documentation</link>.

     

       398
       398
       -
                 '';

     

       397
       397
       +
                   [upstream documentation](https://docs.nextcloud.com/server/22/admin_manual/configuration_files/primary_storage.html).

     

       398
       398
       +
                 '');

     

       399
       399
        
                 bucket = mkOption {

     

       400
       400
        
                   type = types.str;

     

       401
       401
        
                   example = "nextcloud";

     
···

       470
       470
        
             };

     

       471
       471
        
           };

     

       472
       472
        
       

     

       473
       473
       -
           enableImagemagick = mkEnableOption ''

     

       473
       473
       +
           enableImagemagick = mkEnableOption (lib.mdDoc ''

     

       474
       474
        
               the ImageMagick module for PHP.

     

       475
       475
        
               This is used by the theming app and for generating previews of certain images (e.g. SVG and HEIF).

     

       476
       476
        
               You may want to disable it for increased security. In that case, previews will still be available

     

       477
       477
        
               for some images (e.g. JPEG and PNG).

     

       478
       478
       -
               See <link xlink:href="https://github.com/nextcloud/server/issues/13099"/>.

     

       479
       479
       -
           '' // {

     

       478
       478
       +
               See <https://github.com/nextcloud/server/issues/13099>.

     

       479
       479
       +
           '') // {

     

       480
       480
        
             default = true;

     

       481
       481
        
           };

     

       482
       482

+1 -1

nixos/modules/services/web-apps/nexus.nix

···

       11
       11
        
       {

     

       12
       12
        
         options = {

     

       13
       13
        
           services.nexus = {

     

       14
       14
       -
             enable = mkEnableOption "Sonatype Nexus3 OSS service";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "Sonatype Nexus3 OSS service");

     

       15
       15
        
       

     

       16
       16
        
             package = mkOption {

     

       17
       17
        
               type = types.package;

+1 -1

nixos/modules/services/web-apps/nifi.nix

···

       27
       27
        
       in {

     

       28
       28
        
         options = {

     

       29
       29
        
           services.nifi = {

     

       30
       30
       -
             enable = lib.mkEnableOption "Apache NiFi";

     

       30
       30
       +
             enable = lib.mkEnableOption (lib.mdDoc "Apache NiFi");

     

       31
       31
        
       

     

       32
       32
        
             package = lib.mkOption {

     

       33
       33
        
               type = lib.types.package;

+1 -1

nixos/modules/services/web-apps/node-red.nix

···

       17
       17
        
       in

     

       18
       18
        
       {

     

       19
       19
        
         options.services.node-red = {

     

       20
       20
       -
           enable = mkEnableOption "the Node-RED service";

     

       20
       20
       +
           enable = mkEnableOption (lib.mdDoc "the Node-RED service");

     

       21
       21
        
       

     

       22
       22
        
           package = mkOption {

     

       23
       23
        
             default = pkgs.nodePackages.node-red;

+2 -2

nixos/modules/services/web-apps/onlyoffice.nix

···

       7
       7
        
       in

     

       8
       8
        
       {

     

       9
       9
        
         options.services.onlyoffice = {

     

       10
       10
       -
           enable = mkEnableOption "OnlyOffice DocumentServer";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "OnlyOffice DocumentServer");

     

       11
       11
        
       

     

       12
       12
       -
           enableExampleServer = mkEnableOption "OnlyOffice example server";

     

       12
       12
       +
           enableExampleServer = mkEnableOption (lib.mdDoc "OnlyOffice example server");

     

       13
       13
        
       

     

       14
       14
        
           hostname = mkOption {

     

       15
       15
        
             type = types.str;

+1 -1

nixos/modules/services/web-apps/openwebrx.nix

···

       4
       4
        
       in

     

       5
       5
        
       {

     

       6
       6
        
         options.services.openwebrx = with lib; {

     

       7
       7
       -
           enable = mkEnableOption "OpenWebRX Web interface for Software-Defined Radios on http://localhost:8073";

     

       7
       7
       +
           enable = mkEnableOption (lib.mdDoc "OpenWebRX Web interface for Software-Defined Radios on http://localhost:8073");

     

       8
       8
        
       

     

       9
       9
        
           package = mkOption {

     

       10
       10
        
             type = types.package;

+84 -84

nixos/modules/services/web-apps/outline.nix

···

       12
       12
        
         #   https://github.com/outline/outline/blob/v0.65.2/shared/types.ts

     

       13
       13
        
         # The order is kept the same here to make updating easier.

     

       14
       14
        
         options.services.outline = {

     

       15
       15
       -
           enable = lib.mkEnableOption "outline";

     

       15
       15
       +
           enable = lib.mkEnableOption (lib.mdDoc "outline");

     

       16
       16
        
       

     

       17
       17
        
           package = lib.mkOption {

     

       18
       18
        
             default = pkgs.outline;

     
···

       29
       29
        
                 ${"''"};

     

       30
       30
        
               })

     

       31
       31
        
             '';

     

       32
       32
       -
             description = "Outline package to use.";

     

       32
       32
       +
             description = lib.mdDoc "Outline package to use.";

     

       33
       33
        
           };

     

       34
       34
        
       

     

       35
       35
        
           user = lib.mkOption {

     

       36
       36
        
             type = lib.types.str;

     

       37
       37
        
             default = defaultUser;

     

       38
       38
       -
             description = ''

     

       38
       38
       +
             description = lib.mdDoc ''

     

       39
       39
        
               User under which the service should run. If this is the default value,

     

       40
       40
        
               the user will be created, with the specified group as the primary

     

       41
       41
        
               group.

     
···

       45
       45
        
           group = lib.mkOption {

     

       46
       46
        
             type = lib.types.str;

     

       47
       47
        
             default = defaultUser;

     

       48
       48
       -
             description = ''

     

       48
       48
       +
             description = lib.mdDoc ''

     

       49
       49
        
               Group under which the service should run. If this is the default value,

     

       50
       50
        
               the group will be created.

     

       51
       51
        
             '';

     
···

       55
       55
        
             type = lib.types.str;

     

       56
       56
        
             default = "";

     

       57
       57
        
             example = "--env=production-ssl-disabled";

     

       58
       58
       -
             description = ''

     

       59
       59
       -
               Optional arguments to pass to <literal>sequelize</literal> calls.

     

       58
       58
       +
             description = lib.mdDoc ''

     

       59
       59
       +
               Optional arguments to pass to `sequelize` calls.

     

       60
       60
        
             '';

     

       61
       61
        
           };

     

       62
       62
        
       

     
···

       67
       67
        
           secretKeyFile = lib.mkOption {

     

       68
       68
        
             type = lib.types.str;

     

       69
       69
        
             default = "/var/lib/outline/secret_key";

     

       70
       70
       -
             description = ''

     

       70
       70
       +
             description = lib.mdDoc ''

     

       71
       71
        
               File path that contains the application secret key. It must be 32

     

       72
       72
        
               bytes long and hex-encoded. If the file does not exist, a new key will

     

       73
       73
        
               be generated and saved here.

     
···

       77
       77
        
           utilsSecretFile = lib.mkOption {

     

       78
       78
        
             type = lib.types.str;

     

       79
       79
        
             default = "/var/lib/outline/utils_secret";

     

       80
       80
       -
             description = ''

     

       80
       80
       +
             description = lib.mdDoc ''

     

       81
       81
        
               File path that contains the utility secret key. If the file does not

     

       82
       82
        
               exist, a new key will be generated and saved here.

     

       83
       83
        
             '';

     
···

       86
       86
        
           databaseUrl = lib.mkOption {

     

       87
       87
        
             type = lib.types.str;

     

       88
       88
        
             default = "local";

     

       89
       89
       -
             description = ''

     

       89
       89
       +
             description = lib.mdDoc ''

     

       90
       90
        
               URI to use for the main PostgreSQL database. If this needs to include

     

       91
       91
        
               credentials that shouldn't be world-readable in the Nix store, set an

     

       92
       92
        
               environment file on the systemd service and override the

     

       93
       93
       -
               <literal>DATABASE_URL</literal> entry. Pass the string

     

       94
       94
       -
               <literal>local</literal> to setup a database on the local server.

     

       93
       93
       +
               `DATABASE_URL` entry. Pass the string

     

       94
       94
       +
               `local` to setup a database on the local server.

     

       95
       95
        
             '';

     

       96
       96
        
           };

     

       97
       97
        
       

     

       98
       98
        
           redisUrl = lib.mkOption {

     

       99
       99
        
             type = lib.types.str;

     

       100
       100
        
             default = "local";

     

       101
       101
       -
             description = ''

     

       101
       101
       +
             description = lib.mdDoc ''

     

       102
       102
        
               Connection to a redis server. If this needs to include credentials

     

       103
       103
        
               that shouldn't be world-readable in the Nix store, set an environment

     

       104
       104
        
               file on the systemd service and override the

     

       105
       105
       -
               <literal>REDIS_URL</literal> entry. Pass the string

     

       106
       106
       -
               <literal>local</literal> to setup a local Redis database.

     

       105
       105
       +
               `REDIS_URL` entry. Pass the string

     

       106
       106
       +
               `local` to setup a local Redis database.

     

       107
       107
        
             '';

     

       108
       108
        
           };

     

       109
       109
        
       

     

       110
       110
        
           publicUrl = lib.mkOption {

     

       111
       111
        
             type = lib.types.str;

     

       112
       112
        
             default = "http://localhost:3000";

     

       113
       113
       -
             description = "The fully qualified, publicly accessible URL";

     

       113
       113
       +
             description = lib.mdDoc "The fully qualified, publicly accessible URL";

     

       114
       114
        
           };

     

       115
       115
        
       

     

       116
       116
        
           port = lib.mkOption {

     

       117
       117
        
             type = lib.types.port;

     

       118
       118
        
             default = 3000;

     

       119
       119
       -
             description = "Listening port.";

     

       119
       119
       +
             description = lib.mdDoc "Listening port.";

     

       120
       120
        
           };

     

       121
       121
        
       

     

       122
       122
        
           storage = lib.mkOption {

     

       123
       123
       -
             description = ''

     

       123
       123
       +
             description = lib.mdDoc ''

     

       124
       124
        
               To support uploading of images for avatars and document attachments an

     

       125
       125
        
               s3-compatible storage must be provided. AWS S3 is recommended for

     

       126
       126
        
               redundency however if you want to keep all file storage local an

     

       127
       127
       -
               alternative such as <link xlink:href="https://github.com/minio/minio">minio</link>

     

       127
       127
       +
               alternative such as [minio](https://github.com/minio/minio)

     

       128
       128
        
               can be used.

     

       129
       129
        
       

     

       130
       130
        
               A more detailed guide on setting up S3 is available

     

       131
       131
       -
               <link xlink:href="https://wiki.generaloutline.com/share/125de1cc-9ff6-424b-8415-0d58c809a40f">here</link>.

     

       131
       131
       +
               [here](https://wiki.generaloutline.com/share/125de1cc-9ff6-424b-8415-0d58c809a40f).

     

       132
       132
        
             '';

     

       133
       133
        
             example = lib.literalExpression ''

     

       134
       134
        
               {

     
···

       143
       143
        
               options = {

     

       144
       144
        
                 accessKey = lib.mkOption {

     

       145
       145
        
                   type = lib.types.str;

     

       146
       146
       -
                   description = "S3 access key.";

     

       146
       146
       +
                   description = lib.mdDoc "S3 access key.";

     

       147
       147
        
                 };

     

       148
       148
        
                 secretKeyFile = lib.mkOption {

     

       149
       149
        
                   type = lib.types.path;

     

       150
       150
       -
                   description = "File path that contains the S3 secret key.";

     

       150
       150
       +
                   description = lib.mdDoc "File path that contains the S3 secret key.";

     

       151
       151
        
                 };

     

       152
       152
        
                 region = lib.mkOption {

     

       153
       153
        
                   type = lib.types.str;

     

       154
       154
        
                   default = "xx-xxxx-x";

     

       155
       155
       -
                   description = "AWS S3 region name.";

     

       155
       155
       +
                   description = lib.mdDoc "AWS S3 region name.";

     

       156
       156
        
                 };

     

       157
       157
        
                 uploadBucketUrl = lib.mkOption {

     

       158
       158
        
                   type = lib.types.str;

     

       159
       159
       -
                   description = ''

     

       159
       159
       +
                   description = lib.mdDoc ''

     

       160
       160
        
                     URL endpoint of an S3-compatible API where uploads should be

     

       161
       161
        
                     stored.

     

       162
       162
        
                   '';

     

       163
       163
        
                 };

     

       164
       164
        
                 uploadBucketName = lib.mkOption {

     

       165
       165
        
                   type = lib.types.str;

     

       166
       166
       -
                   description = "Name of the bucket where uploads should be stored.";

     

       166
       166
       +
                   description = lib.mdDoc "Name of the bucket where uploads should be stored.";

     

       167
       167
        
                 };

     

       168
       168
        
                 uploadMaxSize = lib.mkOption {

     

       169
       169
        
                   type = lib.types.int;

     

       170
       170
        
                   default = 26214400;

     

       171
       171
       -
                   description = "Maxmium file size for uploads.";

     

       171
       171
       +
                   description = lib.mdDoc "Maxmium file size for uploads.";

     

       172
       172
        
                 };

     

       173
       173
        
                 forcePathStyle = lib.mkOption {

     

       174
       174
        
                   type = lib.types.bool;

     

       175
       175
        
                   default = true;

     

       176
       176
       -
                   description = "Force S3 path style.";

     

       176
       176
       +
                   description = lib.mdDoc "Force S3 path style.";

     

       177
       177
        
                 };

     

       178
       178
        
                 acl = lib.mkOption {

     

       179
       179
        
                   type = lib.types.str;

     

       180
       180
        
                   default = "private";

     

       181
       181
       -
                   description = "ACL setting.";

     

       181
       181
       +
                   description = lib.mdDoc "ACL setting.";

     

       182
       182
        
                 };

     

       183
       183
        
               };

     

       184
       184
        
             };

     
···

       189
       189
        
           #

     

       190
       190
        
       

     

       191
       191
        
           slackAuthentication = lib.mkOption {

     

       192
       192
       -
             description = ''

     

       192
       192
       +
             description = lib.mdDoc ''

     

       193
       193
        
               To configure Slack auth, you'll need to create an Application at

     

       194
       194
        
               https://api.slack.com/apps

     

       195
       195
        
       

     

       196
       196
       -
               When configuring the Client ID, add a redirect URL under "OAuth &amp; Permissions"

     

       197
       197
       -
               to <literal>https://[publicUrl]/auth/slack.callback</literal>.

     

       196
       196
       +
               When configuring the Client ID, add a redirect URL under "OAuth & Permissions"

     

       197
       197
       +
               to `https://[publicUrl]/auth/slack.callback`.

     

       198
       198
        
             '';

     

       199
       199
        
             default = null;

     

       200
       200
        
             type = lib.types.nullOr (lib.types.submodule {

     

       201
       201
        
               options = {

     

       202
       202
        
                 clientId = lib.mkOption {

     

       203
       203
        
                   type = lib.types.str;

     

       204
       204
       -
                   description = "Authentication key.";

     

       204
       204
       +
                   description = lib.mdDoc "Authentication key.";

     

       205
       205
        
                 };

     

       206
       206
        
                 secretFile = lib.mkOption {

     

       207
       207
        
                   type = lib.types.str;

     

       208
       208
       -
                   description = "File path containing the authentication secret.";

     

       208
       208
       +
                   description = lib.mdDoc "File path containing the authentication secret.";

     

       209
       209
        
                 };

     

       210
       210
        
               };

     

       211
       211
        
             });

     

       212
       212
        
           };

     

       213
       213
        
       

     

       214
       214
        
           googleAuthentication = lib.mkOption {

     

       215
       215
       -
             description = ''

     

       215
       215
       +
             description = lib.mdDoc ''

     

       216
       216
        
               To configure Google auth, you'll need to create an OAuth Client ID at

     

       217
       217
        
               https://console.cloud.google.com/apis/credentials

     

       218
       218
        
       

     

       219
       219
        
               When configuring the Client ID, add an Authorized redirect URI to

     

       220
       220
       -
               <literal>https://[publicUrl]/auth/google.callback</literal>.

     

       220
       220
       +
               `https://[publicUrl]/auth/google.callback`.

     

       221
       221
        
             '';

     

       222
       222
        
             default = null;

     

       223
       223
        
             type = lib.types.nullOr (lib.types.submodule {

     

       224
       224
        
               options = {

     

       225
       225
        
                 clientId = lib.mkOption {

     

       226
       226
        
                   type = lib.types.str;

     

       227
       227
       -
                   description = "Authentication client identifier.";

     

       227
       227
       +
                   description = lib.mdDoc "Authentication client identifier.";

     

       228
       228
        
                 };

     

       229
       229
        
                 clientSecretFile = lib.mkOption {

     

       230
       230
        
                   type = lib.types.str;

     

       231
       231
       -
                   description = "File path containing the authentication secret.";

     

       231
       231
       +
                   description = lib.mdDoc "File path containing the authentication secret.";

     

       232
       232
        
                 };

     

       233
       233
        
               };

     

       234
       234
        
             });

     

       235
       235
        
           };

     

       236
       236
        
       

     

       237
       237
        
           azureAuthentication = lib.mkOption {

     

       238
       238
       -
             description = ''

     

       238
       238
       +
             description = lib.mdDoc ''

     

       239
       239
        
               To configure Microsoft/Azure auth, you'll need to create an OAuth

     

       240
       240
        
               Client. See

     

       241
       241
       -
               <link xlink:href="https://wiki.generaloutline.com/share/dfa77e56-d4d2-4b51-8ff8-84ea6608faa4">the guide</link>

     

       241
       241
       +
               [the guide](https://wiki.generaloutline.com/share/dfa77e56-d4d2-4b51-8ff8-84ea6608faa4)

     

       242
       242
        
               for details on setting up your Azure App.

     

       243
       243
        
             '';

     

       244
       244
        
             default = null;

     
···

       246
       246
        
               options = {

     

       247
       247
        
                 clientId = lib.mkOption {

     

       248
       248
        
                   type = lib.types.str;

     

       249
       249
       -
                   description = "Authentication client identifier.";

     

       249
       249
       +
                   description = lib.mdDoc "Authentication client identifier.";

     

       250
       250
        
                 };

     

       251
       251
        
                 clientSecretFile = lib.mkOption {

     

       252
       252
        
                   type = lib.types.str;

     

       253
       253
       -
                   description = "File path containing the authentication secret.";

     

       253
       253
       +
                   description = lib.mdDoc "File path containing the authentication secret.";

     

       254
       254
        
                 };

     

       255
       255
        
                 resourceAppId = lib.mkOption {

     

       256
       256
        
                   type = lib.types.str;

     

       257
       257
       -
                   description = "Authentication application resource ID.";

     

       257
       257
       +
                   description = lib.mdDoc "Authentication application resource ID.";

     

       258
       258
        
                 };

     

       259
       259
        
               };

     

       260
       260
        
             });

     

       261
       261
        
           };

     

       262
       262
        
       

     

       263
       263
        
           oidcAuthentication = lib.mkOption {

     

       264
       264
       -
             description = ''

     

       264
       264
       +
             description = lib.mdDoc ''

     

       265
       265
        
               To configure generic OIDC auth, you'll need some kind of identity

     

       266
       266
        
               provider. See the documentation for whichever IdP you use to fill out

     

       267
       267
        
               all the fields. The redirect URL is

     

       268
       268
       -
               <literal>https://[publicUrl]/auth/oidc.callback</literal>.

     

       268
       268
       +
               `https://[publicUrl]/auth/oidc.callback`.

     

       269
       269
        
             '';

     

       270
       270
        
             default = null;

     

       271
       271
        
             type = lib.types.nullOr (lib.types.submodule {

     

       272
       272
        
               options = {

     

       273
       273
        
                 clientId = lib.mkOption {

     

       274
       274
        
                   type = lib.types.str;

     

       275
       275
       -
                   description = "Authentication client identifier.";

     

       275
       275
       +
                   description = lib.mdDoc "Authentication client identifier.";

     

       276
       276
        
                 };

     

       277
       277
        
                 clientSecretFile = lib.mkOption {

     

       278
       278
        
                   type = lib.types.str;

     

       279
       279
       -
                   description = "File path containing the authentication secret.";

     

       279
       279
       +
                   description = lib.mdDoc "File path containing the authentication secret.";

     

       280
       280
        
                 };

     

       281
       281
        
                 authUrl = lib.mkOption {

     

       282
       282
        
                   type = lib.types.str;

     

       283
       283
       -
                   description = "OIDC authentication URL endpoint.";

     

       283
       283
       +
                   description = lib.mdDoc "OIDC authentication URL endpoint.";

     

       284
       284
        
                 };

     

       285
       285
        
                 tokenUrl = lib.mkOption {

     

       286
       286
        
                   type = lib.types.str;

     

       287
       287
       -
                   description = "OIDC token URL endpoint.";

     

       287
       287
       +
                   description = lib.mdDoc "OIDC token URL endpoint.";

     

       288
       288
        
                 };

     

       289
       289
        
                 userinfoUrl = lib.mkOption {

     

       290
       290
        
                   type = lib.types.str;

     

       291
       291
       -
                   description = "OIDC userinfo URL endpoint.";

     

       291
       291
       +
                   description = lib.mdDoc "OIDC userinfo URL endpoint.";

     

       292
       292
        
                 };

     

       293
       293
        
                 usernameClaim = lib.mkOption {

     

       294
       294
        
                   type = lib.types.str;

     

       295
       295
       -
                   description = ''

     

       295
       295
       +
                   description = lib.mdDoc ''

     

       296
       296
        
                     Specify which claims to derive user information from. Supports any

     

       297
       297
        
                     valid JSON path with the JWT payload

     

       298
       298
        
                   '';

     
···

       300
       300
        
                 };

     

       301
       301
        
                 displayName = lib.mkOption {

     

       302
       302
        
                   type = lib.types.str;

     

       303
       303
       -
                   description = "Display name for OIDC authentication.";

     

       303
       303
       +
                   description = lib.mdDoc "Display name for OIDC authentication.";

     

       304
       304
        
                   default = "OpenID";

     

       305
       305
        
                 };

     

       306
       306
        
                 scopes = lib.mkOption {

     

       307
       307
        
                   type = lib.types.listOf lib.types.str;

     

       308
       308
       -
                   description = "OpenID authentication scopes.";

     

       308
       308
       +
                   description = lib.mdDoc "OpenID authentication scopes.";

     

       309
       309
        
                   default = [ "openid" "profile" "email" ];

     

       310
       310
        
                 };

     

       311
       311
        
               };

     
···

       319
       319
        
           sslKeyFile = lib.mkOption {

     

       320
       320
        
             type = lib.types.nullOr lib.types.str;

     

       321
       321
        
             default = null;

     

       322
       322
       -
             description = ''

     

       322
       322
       +
             description = lib.mdDoc ''

     

       323
       323
        
               File path that contains the Base64-encoded private key for HTTPS

     

       324
       324
        
               termination. This is only required if you do not use an external reverse

     

       325
       325
        
               proxy. See

     

       326
       326
       -
               <link xlink:href="https://wiki.generaloutline.com/share/dfa77e56-d4d2-4b51-8ff8-84ea6608faa4">the documentation</link>.

     

       326
       326
       +
               [the documentation](https://wiki.generaloutline.com/share/dfa77e56-d4d2-4b51-8ff8-84ea6608faa4).

     

       327
       327
        
             '';

     

       328
       328
        
           };

     

       329
       329
        
           sslCertFile = lib.mkOption {

     

       330
       330
        
             type = lib.types.nullOr lib.types.str;

     

       331
       331
        
             default = null;

     

       332
       332
       -
             description = ''

     

       332
       332
       +
             description = lib.mdDoc ''

     

       333
       333
        
               File path that contains the Base64-encoded certificate for HTTPS

     

       334
       334
        
               termination. This is only required if you do not use an external reverse

     

       335
       335
        
               proxy. See

     

       336
       336
       -
               <link xlink:href="https://wiki.generaloutline.com/share/dfa77e56-d4d2-4b51-8ff8-84ea6608faa4">the documentation</link>.

     

       336
       336
       +
               [the documentation](https://wiki.generaloutline.com/share/dfa77e56-d4d2-4b51-8ff8-84ea6608faa4).

     

       337
       337
        
             '';

     

       338
       338
        
           };

     

       339
       339
        
       

     

       340
       340
        
           cdnUrl = lib.mkOption {

     

       341
       341
        
             type = lib.types.str;

     

       342
       342
        
             default = "";

     

       343
       343
       -
             description = ''

     

       343
       343
       +
             description = lib.mdDoc ''

     

       344
       344
        
               If using a Cloudfront/Cloudflare distribution or similar it can be set

     

       345
       345
        
               using this option. This will cause paths to JavaScript files,

     

       346
       346
        
               stylesheets and images to be updated to the hostname defined here. In

     
···

       351
       351
        
           forceHttps = lib.mkOption {

     

       352
       352
        
             type = lib.types.bool;

     

       353
       353
        
             default = true;

     

       354
       354
       -
             description = ''

     

       354
       354
       +
             description = lib.mdDoc ''

     

       355
       355
        
               Auto-redirect to HTTPS in production. The default is

     

       356
       356
       -
               <literal>true</literal> but you may set this to <literal>false</literal>

     

       356
       356
       +
               `true` but you may set this to `false`

     

       357
       357
        
               if you can be sure that SSL is terminated at an external loadbalancer.

     

       358
       358
        
             '';

     

       359
       359
        
           };

     
···

       361
       361
        
           enableUpdateCheck = lib.mkOption {

     

       362
       362
        
             type = lib.types.bool;

     

       363
       363
        
             default = false;

     

       364
       364
       -
             description = ''

     

       364
       364
       +
             description = lib.mdDoc ''

     

       365
       365
        
               Have the installation check for updates by sending anonymized statistics

     

       366
       366
        
               to the maintainers.

     

       367
       367
        
             '';

     
···

       370
       370
        
           concurrency = lib.mkOption {

     

       371
       371
        
             type = lib.types.int;

     

       372
       372
        
             default = 1;

     

       373
       373
       -
             description = ''

     

       373
       373
       +
             description = lib.mdDoc ''

     

       374
       374
        
               How many processes should be spawned. For a rough estimate, divide your

     

       375
       375
        
               server's available memory by 512.

     

       376
       376
        
             '';

     
···

       379
       379
        
           maximumImportSize = lib.mkOption {

     

       380
       380
        
             type = lib.types.int;

     

       381
       381
        
             default = 5120000;

     

       382
       382
       -
             description = ''

     

       382
       382
       +
             description = lib.mdDoc ''

     

       383
       383
        
               The maximum size of document imports. Overriding this could be required

     

       384
       384
        
               if you have especially large Word documents with embedded imagery.

     

       385
       385
        
             '';

     
···

       388
       388
        
           debugOutput = lib.mkOption {

     

       389
       389
        
             type = lib.types.nullOr (lib.types.enum [ "http" ]);

     

       390
       390
        
             default = null;

     

       391
       391
       -
             description = "Set this to <literal>http</literal> log HTTP requests.";

     

       391
       391
       +
             description = lib.mdDoc "Set this to `http` log HTTP requests.";

     

       392
       392
        
           };

     

       393
       393
        
       

     

       394
       394
        
           slackIntegration = lib.mkOption {

     

       395
       395
       -
             description = ''

     

       395
       395
       +
             description = lib.mdDoc ''

     

       396
       396
        
               For a complete Slack integration with search and posting to channels

     

       397
       397
        
               this configuration is also needed. See here for details:

     

       398
       398
        
               https://wiki.generaloutline.com/share/be25efd1-b3ef-4450-b8e5-c4a4fc11e02a

     
···

       402
       402
        
               options = {

     

       403
       403
        
                 verificationTokenFile = lib.mkOption {

     

       404
       404
        
                   type = lib.types.str;

     

       405
       405
       -
                   description = "File path containing the verification token.";

     

       405
       405
       +
                   description = lib.mdDoc "File path containing the verification token.";

     

       406
       406
        
                 };

     

       407
       407
        
                 appId = lib.mkOption {

     

       408
       408
        
                   type = lib.types.str;

     

       409
       409
       -
                   description = "Application ID.";

     

       409
       409
       +
                   description = lib.mdDoc "Application ID.";

     

       410
       410
        
                 };

     

       411
       411
        
                 messageActions = lib.mkOption {

     

       412
       412
        
                   type = lib.types.bool;

     

       413
       413
        
                   default = true;

     

       414
       414
       -
                   description = "Whether to enable message actions.";

     

       414
       414
       +
                   description = lib.mdDoc "Whether to enable message actions.";

     

       415
       415
        
                 };

     

       416
       416
        
               };

     

       417
       417
        
             });

     
···

       420
       420
        
           googleAnalyticsId = lib.mkOption {

     

       421
       421
        
             type = lib.types.nullOr lib.types.str;

     

       422
       422
        
             default = null;

     

       423
       423
       -
             description = ''

     

       423
       423
       +
             description = lib.mdDoc ''

     

       424
       424
        
               Optionally enable Google Analytics to track page views in the knowledge

     

       425
       425
        
               base.

     

       426
       426
        
             '';

     
···

       429
       429
        
           sentryDsn = lib.mkOption {

     

       430
       430
        
             type = lib.types.nullOr lib.types.str;

     

       431
       431
        
             default = null;

     

       432
       432
       -
             description = ''

     

       433
       433
       -
               Optionally enable <link xlink:href="https://sentry.io/">Sentry</link> to

     

       432
       432
       +
             description = lib.mdDoc ''

     

       433
       433
       +
               Optionally enable [Sentry](https://sentry.io/) to

     

       434
       434
        
               track errors and performance.

     

       435
       435
        
             '';

     

       436
       436
        
           };

     
···

       438
       438
        
           logo = lib.mkOption {

     

       439
       439
        
             type = lib.types.nullOr lib.types.str;

     

       440
       440
        
             default = null;

     

       441
       441
       -
             description = ''

     

       441
       441
       +
             description = lib.mdDoc ''

     

       442
       442
        
               Custom logo displayed on the authentication screen. This will be scaled

     

       443
       443
        
               to a height of 60px.

     

       444
       444
        
             '';

     

       445
       445
        
           };

     

       446
       446
        
       

     

       447
       447
        
           smtp = lib.mkOption {

     

       448
       448
       -
             description = ''

     

       448
       448
       +
             description = lib.mdDoc ''

     

       449
       449
        
               To support sending outgoing transactional emails such as

     

       450
       450
        
               "document updated" or "you've been invited" you'll need to provide

     

       451
       451
        
               authentication for an SMTP server.

     
···

       455
       455
        
               options = {

     

       456
       456
        
                 host = lib.mkOption {

     

       457
       457
        
                   type = lib.types.str;

     

       458
       458
       -
                   description = "Host name or IP adress of the SMTP server.";

     

       458
       458
       +
                   description = lib.mdDoc "Host name or IP adress of the SMTP server.";

     

       459
       459
        
                 };

     

       460
       460
        
                 port = lib.mkOption {

     

       461
       461
        
                   type = lib.types.port;

     

       462
       462
       -
                   description = "TCP port of the SMTP server.";

     

       462
       462
       +
                   description = lib.mdDoc "TCP port of the SMTP server.";

     

       463
       463
        
                 };

     

       464
       464
        
                 username = lib.mkOption {

     

       465
       465
        
                   type = lib.types.str;

     

       466
       466
       -
                   description = "Username to authenticate with.";

     

       466
       466
       +
                   description = lib.mdDoc "Username to authenticate with.";

     

       467
       467
        
                 };

     

       468
       468
        
                 passwordFile = lib.mkOption {

     

       469
       469
        
                   type = lib.types.str;

     

       470
       470
       -
                   description = ''

     

       470
       470
       +
                   description = lib.mdDoc ''

     

       471
       471
        
                     File path containing the password to authenticate with.

     

       472
       472
        
                   '';

     

       473
       473
        
                 };

     

       474
       474
        
                 fromEmail = lib.mkOption {

     

       475
       475
        
                   type = lib.types.str;

     

       476
       476
       -
                   description = "Sender email in outgoing mail.";

     

       476
       476
       +
                   description = lib.mdDoc "Sender email in outgoing mail.";

     

       477
       477
        
                 };

     

       478
       478
        
                 replyEmail = lib.mkOption {

     

       479
       479
        
                   type = lib.types.str;

     

       480
       480
       -
                   description = "Reply address in outgoing mail.";

     

       480
       480
       +
                   description = lib.mdDoc "Reply address in outgoing mail.";

     

       481
       481
        
                 };

     

       482
       482
        
                 tlsCiphers = lib.mkOption {

     

       483
       483
        
                   type = lib.types.str;

     

       484
       484
        
                   default = "";

     

       485
       485
       -
                   description = "Override SMTP cipher configuration.";

     

       485
       485
       +
                   description = lib.mdDoc "Override SMTP cipher configuration.";

     

       486
       486
        
                 };

     

       487
       487
        
                 secure = lib.mkOption {

     

       488
       488
        
                   type = lib.types.bool;

     

       489
       489
        
                   default = true;

     

       490
       490
       -
                   description = "Use a secure SMTP connection.";

     

       490
       490
       +
                   description = lib.mdDoc "Use a secure SMTP connection.";

     

       491
       491
        
                 };

     

       492
       492
        
               };

     

       493
       493
        
             });

     
···

       516
       516
        
                "zh_TW"

     

       517
       517
        
             ];

     

       518
       518
        
             default = "en_US";

     

       519
       519
       -
             description = ''

     

       519
       519
       +
             description = lib.mdDoc ''

     

       520
       520
        
               The default interface language. See

     

       521
       521
       -
               <link xlink:href="https://translate.getoutline.com/">translate.getoutline.com</link>

     

       521
       521
       +
               [translate.getoutline.com](https://translate.getoutline.com/)

     

       522
       522
        
               for a list of available language codes and their rough percentage

     

       523
       523
        
               translated.

     

       524
       524
        
             '';

     

       525
       525
        
           };

     

       526
       526
        
       

     

       527
       527
       -
           rateLimiter.enable = lib.mkEnableOption "rate limiter for the application web server";

     

       527
       527
       +
           rateLimiter.enable = lib.mkEnableOption (lib.mdDoc "rate limiter for the application web server");

     

       528
       528
        
           rateLimiter.requests = lib.mkOption {

     

       529
       529
        
             type = lib.types.int;

     

       530
       530
        
             default = 5000;

     

       531
       531
       -
             description = "Maximum number of requests in a throttling window.";

     

       531
       531
       +
             description = lib.mdDoc "Maximum number of requests in a throttling window.";

     

       532
       532
        
           };

     

       533
       533
        
           rateLimiter.durationWindow = lib.mkOption {

     

       534
       534
        
             type = lib.types.int;

     

       535
       535
        
             default = 60;

     

       536
       536
       -
             description = "Length of a throttling window.";

     

       536
       536
       +
             description = lib.mdDoc "Length of a throttling window.";

     

       537
       537
        
           };

     

       538
       538
        
         };

     

       539
       539

+1 -1

nixos/modules/services/web-apps/peertube.nix

···

       69
       69
        
       

     

       70
       70
        
       in {

     

       71
       71
        
         options.services.peertube = {

     

       72
       72
       -
           enable = lib.mkEnableOption "Enable Peertube’s service";

     

       72
       72
       +
           enable = lib.mkEnableOption (lib.mdDoc "Enable Peertube’s service");

     

       73
       73
        
       

     

       74
       74
        
           user = lib.mkOption {

     

       75
       75
        
             type = lib.types.str;

+1 -1

nixos/modules/services/web-apps/pgpkeyserver-lite.nix

···

       18
       18
        
       

     

       19
       19
        
           services.pgpkeyserver-lite = {

     

       20
       20
        
       

     

       21
       21
       -
             enable = mkEnableOption "pgpkeyserver-lite on a nginx vHost proxying to a gpg keyserver";

     

       21
       21
       +
             enable = mkEnableOption (lib.mdDoc "pgpkeyserver-lite on a nginx vHost proxying to a gpg keyserver");

     

       22
       22
        
       

     

       23
       23
        
             package = mkOption {

     

       24
       24
        
               default = pkgs.pgpkeyserver-lite;

+1 -1

nixos/modules/services/web-apps/phylactery.nix

···

       4
       4
        
       let cfg = config.services.phylactery;

     

       5
       5
        
       in {

     

       6
       6
        
         options.services.phylactery = {

     

       7
       7
       -
           enable = mkEnableOption "Whether to enable Phylactery server";

     

       7
       7
       +
           enable = mkEnableOption (lib.mdDoc "Whether to enable Phylactery server");

     

       8
       8
        
       

     

       9
       9
        
           host = mkOption {

     

       10
       10
        
             type = types.str;

+1 -1

nixos/modules/services/web-apps/pict-rs.nix

···

       10
       10
        
         meta.doc = ./pict-rs.xml;

     

       11
       11
        
       

     

       12
       12
        
         options.services.pict-rs = {

     

       13
       13
       -
           enable = mkEnableOption "pict-rs server";

     

       13
       13
       +
           enable = mkEnableOption (lib.mdDoc "pict-rs server");

     

       14
       14
        
           dataDir = mkOption {

     

       15
       15
        
             type = types.path;

     

       16
       16
        
             default = "/var/lib/pict-rs";

+1 -1

nixos/modules/services/web-apps/plantuml-server.nix

···

       11
       11
        
       {

     

       12
       12
        
         options = {

     

       13
       13
        
           services.plantuml-server = {

     

       14
       14
       -
             enable = mkEnableOption "PlantUML server";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "PlantUML server");

     

       15
       15
        
       

     

       16
       16
        
             package = mkOption {

     

       17
       17
        
               type = types.package;

+5 -5

nixos/modules/services/web-apps/plausible.nix

···

       7
       7
        
       

     

       8
       8
        
       in {

     

       9
       9
        
         options.services.plausible = {

     

       10
       10
       -
           enable = mkEnableOption "plausible";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "plausible");

     

       11
       11
        
       

     

       12
       12
        
           releaseCookiePath = mkOption {

     

       13
       13
        
             type = with types; either str path;

     
···

       40
       40
        
               '';

     

       41
       41
        
             };

     

       42
       42
        
       

     

       43
       43
       -
             activate = mkEnableOption "activating the freshly created admin-user";

     

       43
       43
       +
             activate = mkEnableOption (lib.mdDoc "activating the freshly created admin-user");

     

       44
       44
        
           };

     

       45
       45
        
       

     

       46
       46
        
           database = {

     

       47
       47
        
             clickhouse = {

     

       48
       48
       -
               setup = mkEnableOption "creating a clickhouse instance" // { default = true; };

     

       48
       48
       +
               setup = mkEnableOption (lib.mdDoc "creating a clickhouse instance") // { default = true; };

     

       49
       49
        
               url = mkOption {

     

       50
       50
        
                 default = "http://localhost:8123/default";

     

       51
       51
        
                 type = types.str;

     
···

       55
       55
        
               };

     

       56
       56
        
             };

     

       57
       57
        
             postgres = {

     

       58
       58
       -
               setup = mkEnableOption "creating a postgresql instance" // { default = true; };

     

       58
       58
       +
               setup = mkEnableOption (lib.mdDoc "creating a postgresql instance") // { default = true; };

     

       59
       59
        
               dbname = mkOption {

     

       60
       60
        
                 default = "plausible";

     

       61
       61
        
                 type = types.str;

     
···

       148
       148
        
                   The path to the file with the password in case SMTP auth is enabled.

     

       149
       149
        
                 '';

     

       150
       150
        
               };

     

       151
       151
       -
               enableSSL = mkEnableOption "SSL when connecting to the SMTP server";

     

       151
       151
       +
               enableSSL = mkEnableOption (lib.mdDoc "SSL when connecting to the SMTP server");

     

       152
       152
        
               retries = mkOption {

     

       153
       153
        
                 type = types.ints.unsigned;

     

       154
       154
        
                 default = 2;

+1 -1

nixos/modules/services/web-apps/powerdns-admin.nix

···

       19
       19
        
       in

     

       20
       20
        
       {

     

       21
       21
        
         options.services.powerdns-admin = {

     

       22
       22
       -
           enable = mkEnableOption "the PowerDNS web interface";

     

       22
       22
       +
           enable = mkEnableOption (lib.mdDoc "the PowerDNS web interface");

     

       23
       23
        
       

     

       24
       24
        
           extraArgs = mkOption {

     

       25
       25
        
             type = types.listOf types.str;

+1 -1

nixos/modules/services/web-apps/prosody-filer.nix

···

       11
       11
        
       

     

       12
       12
        
         options = {

     

       13
       13
        
           services.prosody-filer = {

     

       14
       14
       -
             enable = mkEnableOption "Prosody Filer XMPP upload file server";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "Prosody Filer XMPP upload file server");

     

       15
       15
        
       

     

       16
       16
        
             settings = mkOption {

     

       17
       17
        
               description = lib.mdDoc ''

+1 -1

nixos/modules/services/web-apps/restya-board.nix

···

       25
       25
        
       

     

       26
       26
        
           services.restya-board = {

     

       27
       27
        
       

     

       28
       28
       -
             enable = mkEnableOption "restya-board";

     

       28
       28
       +
             enable = mkEnableOption (lib.mdDoc "restya-board");

     

       29
       29
        
       

     

       30
       30
        
             dataDir = mkOption {

     

       31
       31
        
               type = types.path;

+1 -1

nixos/modules/services/web-apps/rss-bridge.nix

···

       11
       11
        
       {

     

       12
       12
        
         options = {

     

       13
       13
        
           services.rss-bridge = {

     

       14
       14
       -
             enable = mkEnableOption "rss-bridge";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "rss-bridge");

     

       15
       15
        
       

     

       16
       16
        
             user = mkOption {

     

       17
       17
        
               type = types.str;

+1 -1

nixos/modules/services/web-apps/selfoss.nix

···

       30
       30
        
         {

     

       31
       31
        
           options = {

     

       32
       32
        
             services.selfoss = {

     

       33
       33
       -
               enable = mkEnableOption "selfoss";

     

       33
       33
       +
               enable = mkEnableOption (lib.mdDoc "selfoss");

     

       34
       34
        
       

     

       35
       35
        
               user = mkOption {

     

       36
       36
        
                 type = types.str;

+1 -1

nixos/modules/services/web-apps/shiori.nix

···

       6
       6
        
       in {

     

       7
       7
        
         options = {

     

       8
       8
        
           services.shiori = {

     

       9
       9
       -
             enable = mkEnableOption "Shiori simple bookmarks manager";

     

       9
       9
       +
             enable = mkEnableOption (lib.mdDoc "Shiori simple bookmarks manager");

     

       10
       10
        
       

     

       11
       11
        
             package = mkOption {

     

       12
       12
        
               type = types.package;

+1 -1

nixos/modules/services/web-apps/snipe-it.nix

···

       28
       28
        
       in {

     

       29
       29
        
         options.services.snipe-it = {

     

       30
       30
        
       

     

       31
       31
       -
           enable = mkEnableOption "A free open source IT asset/license management system";

     

       31
       31
       +
           enable = mkEnableOption (lib.mdDoc "A free open source IT asset/license management system");

     

       32
       32
        
       

     

       33
       33
        
           user = mkOption {

     

       34
       34
        
             default = "snipeit";

+1 -1

nixos/modules/services/web-apps/sogo.nix

···

       18
       18
        
       

     

       19
       19
        
       in {

     

       20
       20
        
         options.services.sogo = with types; {

     

       21
       21
       -
           enable = mkEnableOption "SOGo groupware";

     

       21
       21
       +
           enable = mkEnableOption (lib.mdDoc "SOGo groupware");

     

       22
       22
        
       

     

       23
       23
        
           vhostName = mkOption {

     

       24
       24
        
             description = lib.mdDoc "Name of the nginx vhost";

+1 -1

nixos/modules/services/web-apps/trilium.nix

···

       24
       24
        
       {

     

       25
       25
        
       

     

       26
       26
        
         options.services.trilium-server = with lib; {

     

       27
       27
       -
           enable = mkEnableOption "trilium-server";

     

       27
       27
       +
           enable = mkEnableOption (lib.mdDoc "trilium-server");

     

       28
       28
        
       

     

       29
       29
        
           dataDir = mkOption {

     

       30
       30
        
             type = types.str;

+1 -1

nixos/modules/services/web-apps/tt-rss.nix

···

       121
       121
        
       

     

       122
       122
        
           services.tt-rss = {

     

       123
       123
        
       

     

       124
       124
       -
             enable = mkEnableOption "tt-rss";

     

       124
       124
       +
             enable = mkEnableOption (lib.mdDoc "tt-rss");

     

       125
       125
        
       

     

       126
       126
        
             root = mkOption {

     

       127
       127
        
               type = types.path;

+1 -1

nixos/modules/services/web-apps/vikunja.nix

···

       10
       10
        
         usePostgresql = cfg.database.type == "postgres";

     

       11
       11
        
       in {

     

       12
       12
        
         options.services.vikunja = with lib; {

     

       13
       13
       -
           enable = mkEnableOption "vikunja service";

     

       13
       13
       +
           enable = mkEnableOption (lib.mdDoc "vikunja service");

     

       14
       14
        
           package-api = mkOption {

     

       15
       15
        
             default = pkgs.vikunja-api;

     

       16
       16
        
             type = types.package;

+1 -1

nixos/modules/services/web-apps/whitebophir.nix

···

       7
       7
        
       in {

     

       8
       8
        
         options = {

     

       9
       9
        
           services.whitebophir = {

     

       10
       10
       -
             enable = mkEnableOption "whitebophir, an online collaborative whiteboard server (persistent state will be maintained under <filename>/var/lib/whitebophir</filename>)";

     

       10
       10
       +
             enable = mkEnableOption (lib.mdDoc "whitebophir, an online collaborative whiteboard server (persistent state will be maintained under {file}`/var/lib/whitebophir`)");

     

       11
       11
        
       

     

       12
       12
        
             package = mkOption {

     

       13
       13
        
               default = pkgs.whitebophir;

+1 -1

nixos/modules/services/web-apps/wiki-js.nix

···

       10
       10
        
         configFile = format.generate "wiki-js.yml" cfg.settings;

     

       11
       11
        
       in {

     

       12
       12
        
         options.services.wiki-js = {

     

       13
       13
       -
           enable = mkEnableOption "wiki-js";

     

       13
       13
       +
           enable = mkEnableOption (lib.mdDoc "wiki-js");

     

       14
       14
        
       

     

       15
       15
        
           environmentFile = mkOption {

     

       16
       16
        
             type = types.nullOr types.path;

+1 -1

nixos/modules/services/web-apps/youtrack.nix

···

       21
       21
        
       {

     

       22
       22
        
         options.services.youtrack = {

     

       23
       23
        
       

     

       24
       24
       -
           enable = mkEnableOption "YouTrack service";

     

       24
       24
       +
           enable = mkEnableOption (lib.mdDoc "YouTrack service");

     

       25
       25
        
       

     

       26
       26
        
           address = mkOption {

     

       27
       27
        
             description = lib.mdDoc ''

+1 -1

nixos/modules/services/web-apps/zabbix.nix

···

       40
       40
        
       

     

       41
       41
        
         options.services = {

     

       42
       42
        
           zabbixWeb = {

     

       43
       43
       -
             enable = mkEnableOption "the Zabbix web interface";

     

       43
       43
       +
             enable = mkEnableOption (lib.mdDoc "the Zabbix web interface");

     

       44
       44
        
       

     

       45
       45
        
             package = mkOption {

     

       46
       46
        
               type = types.package;

+1 -1

nixos/modules/services/web-servers/agate.nix

···

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.agate = {

     

       11
       11
       -
             enable = mkEnableOption "Agate Server";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "Agate Server");

     

       12
       12
        
       

     

       13
       13
        
             package = mkOption {

     

       14
       14
        
               type = types.package;

+3 -3

nixos/modules/services/web-servers/apache-httpd/default.nix

···

       404
       404
        
       

     

       405
       405
        
           services.httpd = {

     

       406
       406
        
       

     

       407
       407
       -
             enable = mkEnableOption "the Apache HTTP Server";

     

       407
       407
       +
             enable = mkEnableOption (lib.mdDoc "the Apache HTTP Server");

     

       408
       408
        
       

     

       409
       409
        
             package = mkOption {

     

       410
       410
        
               type = types.package;

     
···

       445
       445
        
                   { name = "jk"; path = "''${pkgs.tomcat_connectors}/modules/mod_jk.so"; }

     

       446
       446
        
                 ]

     

       447
       447
        
               '';

     

       448
       448
       -
               description = ''

     

       448
       448
       +
               description = lib.mdDoc ''

     

       449
       449
        
                 Additional Apache modules to be used. These can be

     

       450
       450
        
                 specified as a string in the case of modules distributed

     

       451
       451
        
                 with Apache, or as an attribute set specifying the

     

       452
       452
       -
                 <varname>name</varname> and <varname>path</varname> of the

     

       452
       452
       +
                 {var}`name` and {var}`path` of the

     

       453
       453
        
                 module.

     

       454
       454
        
               '';

     

       455
       455
        
             };

+1 -1

nixos/modules/services/web-servers/caddy/default.nix

···

       52
       52
        
       

     

       53
       53
        
         # interface

     

       54
       54
        
         options.services.caddy = {

     

       55
       55
       -
           enable = mkEnableOption "Caddy web server";

     

       55
       55
       +
           enable = mkEnableOption (lib.mdDoc "Caddy web server");

     

       56
       56
        
       

     

       57
       57
        
           user = mkOption {

     

       58
       58
        
             default = "caddy";

+3 -3

nixos/modules/services/web-servers/caddy/vhost-options.nix

···

       33
       33
        
           useACMEHost = mkOption {

     

       34
       34
        
             type = types.nullOr types.str;

     

       35
       35
        
             default = null;

     

       36
       36
       -
             description = ''

     

       36
       36
       +
             description = lib.mdDoc ''

     

       37
       37
        
               A host of an existing Let's Encrypt certificate to use.

     

       38
       38
        
               This is mostly useful if you use DNS challenges but Caddy does not

     

       39
       39
        
               currently support your provider.

     

       40
       40
        
       

     

       41
       41
       -
               <emphasis>Note that this option does not create any certificates, nor

     

       41
       41
       +
               *Note that this option does not create any certificates, nor

     

       42
       42
        
               does it add subdomains to existing ones – you will need to create them

     

       43
       43
       -
               manually using <xref linkend="opt-security.acme.certs"/>.</emphasis>

     

       43
       43
       +
               manually using [](#opt-security.acme.certs).*

     

       44
       44
        
             '';

     

       45
       45
        
           };

     

       46
       46

+1 -1

nixos/modules/services/web-servers/darkhttpd.nix

···

       15
       15
        
       

     

       16
       16
        
       in {

     

       17
       17
        
         options.services.darkhttpd = with types; {

     

       18
       18
       -
           enable = mkEnableOption "DarkHTTPd web server";

     

       18
       18
       +
           enable = mkEnableOption (lib.mdDoc "DarkHTTPd web server");

     

       19
       19
        
       

     

       20
       20
        
           port = mkOption {

     

       21
       21
        
             default = 80;

+1 -1

nixos/modules/services/web-servers/hitch/default.nix

···

       17
       17
        
       {

     

       18
       18
        
         options = {

     

       19
       19
        
           services.hitch = {

     

       20
       20
       -
             enable = mkEnableOption "Hitch Server";

     

       20
       20
       +
             enable = mkEnableOption (lib.mdDoc "Hitch Server");

     

       21
       21
        
       

     

       22
       22
        
             backend = mkOption {

     

       23
       23
        
               type = types.str;

+1 -1

nixos/modules/services/web-servers/hydron.nix

···

       4
       4
        
         cfg = config.services.hydron;

     

       5
       5
        
       in with lib; {

     

       6
       6
        
         options.services.hydron = {

     

       7
       7
       -
           enable = mkEnableOption "hydron";

     

       7
       7
       +
           enable = mkEnableOption (lib.mdDoc "hydron");

     

       8
       8
        
       

     

       9
       9
        
           dataDir = mkOption {

     

       10
       10
        
             type = types.path;

+10 -10

nixos/modules/services/web-servers/keter/default.nix

···

       8
       8
        
         };

     

       9
       9
        
       

     

       10
       10
        
         options.services.keter = {

     

       11
       11
       -
           enable = lib.mkEnableOption ''keter, a web app deployment manager.

     

       11
       11
       +
           enable = lib.mkEnableOption (lib.mdDoc ''keter, a web app deployment manager.

     

       12
       12
        
       Note that this module only support loading of webapps:

     

       13
       13
        
       Keep an old app running and swap the ports when the new one is booted.

     

       14
       14
       -
       '';

     

       14
       14
       +
       '');

     

       15
       15
        
       

     

       16
       16
        
           keterRoot = lib.mkOption {

     

       17
       17
        
             type = lib.types.str;

     

       18
       18
        
             default = "/var/lib/keter";

     

       19
       19
       -
             description = "Mutable state folder for keter";

     

       19
       19
       +
             description = lib.mdDoc "Mutable state folder for keter";

     

       20
       20
        
           };

     

       21
       21
        
       

     

       22
       22
        
           keterPackage = lib.mkOption {

     

       23
       23
        
             type = lib.types.package;

     

       24
       24
        
             default = pkgs.haskellPackages.keter;

     

       25
       25
        
             defaultText = lib.literalExpression "pkgs.haskellPackages.keter";

     

       26
       26
       -
             description = "The keter package to be used";

     

       26
       26
       +
             description = lib.mdDoc "The keter package to be used";

     

       27
       27
        
           };

     

       28
       28
        
       

     

       29
       29
        
           globalKeterConfig = lib.mkOption {

     
···

       47
       47
        
                 }];

     

       48
       48
        
               }

     

       49
       49
        
             '';

     

       50
       50
       -
             description = "Global config for keter";

     

       50
       50
       +
             description = lib.mdDoc "Global config for keter";

     

       51
       51
        
           };

     

       52
       52
        
       

     

       53
       53
        
           bundle = {

     

       54
       54
        
             appName = lib.mkOption {

     

       55
       55
        
               type = lib.types.str;

     

       56
       56
        
               default = "myapp";

     

       57
       57
       -
               description = "The name keter assigns to this bundle";

     

       57
       57
       +
               description = lib.mdDoc "The name keter assigns to this bundle";

     

       58
       58
        
             };

     

       59
       59
        
       

     

       60
       60
        
             executable = lib.mkOption {

     

       61
       61
        
               type = lib.types.path;

     

       62
       62
       -
               description = "The executable to be run";

     

       62
       62
       +
               description = lib.mdDoc "The executable to be run";

     

       63
       63
        
             };

     

       64
       64
        
       

     

       65
       65
        
             domain = lib.mkOption {

     

       66
       66
        
               type = lib.types.str;

     

       67
       67
        
               default = "example.com";

     

       68
       68
       -
               description = "The domain keter will bind to";

     

       68
       68
       +
               description = lib.mdDoc "The domain keter will bind to";

     

       69
       69
        
             };

     

       70
       70
        
       

     

       71
       71
        
             publicScript = lib.mkOption {

     

       72
       72
        
               type = lib.types.str;

     

       73
       73
        
               default = "";

     

       74
       74
       -
               description = ''

     

       74
       74
       +
               description = lib.mdDoc ''

     

       75
       75
        
                 Allows loading of public environment variables,

     

       76
       76
        
                 these are emitted to the log so it shouldn't contain secrets.

     

       77
       77
        
               '';

     
···

       81
       81
        
             secretScript = lib.mkOption {

     

       82
       82
        
               type = lib.types.str;

     

       83
       83
        
               default = "";

     

       84
       84
       -
               description = "Allows loading of private environment variables";

     

       84
       84
       +
               description = lib.mdDoc "Allows loading of private environment variables";

     

       85
       85
        
               example = "MY_AWS_KEY=$(cat /run/keys/AWS_ACCESS_KEY_ID)";

     

       86
       86
        
             };

     

       87
       87
        
           };

+1 -1

nixos/modules/services/web-servers/lighttpd/collectd.nix

···

       25
       25
        
       

     

       26
       26
        
         options.services.lighttpd.collectd = {

     

       27
       27
        
       

     

       28
       28
       -
           enable = mkEnableOption "collectd subservice accessible at http://yourserver/collectd";

     

       28
       28
       +
           enable = mkEnableOption (lib.mdDoc "collectd subservice accessible at http://yourserver/collectd");

     

       29
       29
        
       

     

       30
       30
        
           collectionCgi = mkOption {

     

       31
       31
        
             type = types.path;

+1 -1

nixos/modules/services/web-servers/mighttpd2.nix

···

       8
       8
        
         routingFile = pkgs.writeText "mighty-routing" cfg.routing;

     

       9
       9
        
       in {

     

       10
       10
        
         options.services.mighttpd2 = {

     

       11
       11
       -
           enable = mkEnableOption "Mighttpd2 web server";

     

       11
       11
       +
           enable = mkEnableOption (lib.mdDoc "Mighttpd2 web server");

     

       12
       12
        
       

     

       13
       13
        
           config = mkOption {

     

       14
       14
        
             default = "";

+1 -1

nixos/modules/services/web-servers/minio.nix

···

       14
       14
        
         meta.maintainers = [ maintainers.bachp ];

     

       15
       15
        
       

     

       16
       16
        
         options.services.minio = {

     

       17
       17
       -
           enable = mkEnableOption "Minio Object Storage";

     

       17
       17
       +
           enable = mkEnableOption (lib.mdDoc "Minio Object Storage");

     

       18
       18
        
       

     

       19
       19
        
           listenAddress = mkOption {

     

       20
       20
        
             default = ":9000";

+1 -1

nixos/modules/services/web-servers/molly-brown.nix

···

       10
       10
        
       

     

       11
       11
        
         options.services.molly-brown = {

     

       12
       12
        
       

     

       13
       13
       -
           enable = mkEnableOption "Molly-Brown Gemini server";

     

       13
       13
       +
           enable = mkEnableOption (lib.mdDoc "Molly-Brown Gemini server");

     

       14
       14
        
       

     

       15
       15
        
           port = mkOption {

     

       16
       16
        
             default = 1965;

+1 -1

nixos/modules/services/web-servers/nginx/default.nix

···

       385
       385
        
       {

     

       386
       386
        
         options = {

     

       387
       387
        
           services.nginx = {

     

       388
       388
       -
             enable = mkEnableOption "Nginx Web Server";

     

       388
       388
       +
             enable = mkEnableOption (lib.mdDoc "Nginx Web Server");

     

       389
       389
        
       

     

       390
       390
        
             statusPage = mkOption {

     

       391
       391
        
               default = false;

+1 -1

nixos/modules/services/web-servers/pomerium.nix

···

       7
       7
        
       in

     

       8
       8
        
       {

     

       9
       9
        
         options.services.pomerium = {

     

       10
       10
       -
           enable = mkEnableOption "the Pomerium authenticating reverse proxy";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "the Pomerium authenticating reverse proxy");

     

       11
       11
        
       

     

       12
       12
        
           configFile = mkOption {

     

       13
       13
        
             type = with types; nullOr path;

+1 -1

nixos/modules/services/web-servers/tomcat.nix

···

       19
       19
        
         options = {

     

       20
       20
        
       

     

       21
       21
        
           services.tomcat = {

     

       22
       22
       -
             enable = mkEnableOption "Apache Tomcat";

     

       22
       22
       +
             enable = mkEnableOption (lib.mdDoc "Apache Tomcat");

     

       23
       23
        
       

     

       24
       24
        
             package = mkOption {

     

       25
       25
        
               type = types.package;

+1 -1

nixos/modules/services/web-servers/traefik.nix

···

       50
       50
        
           cfg.staticConfigFile;

     

       51
       51
        
       in {

     

       52
       52
        
         options.services.traefik = {

     

       53
       53
       -
           enable = mkEnableOption "Traefik web server";

     

       53
       53
       +
           enable = mkEnableOption (lib.mdDoc "Traefik web server");

     

       54
       54
        
       

     

       55
       55
        
           staticConfigFile = mkOption {

     

       56
       56
        
             default = null;

+1 -1

nixos/modules/services/web-servers/trafficserver/default.nix

···

       33
       33
        
       in

     

       34
       34
        
       {

     

       35
       35
        
         options.services.trafficserver = {

     

       36
       36
       -
           enable = mkEnableOption "Apache Traffic Server";

     

       36
       36
       +
           enable = mkEnableOption (lib.mdDoc "Apache Traffic Server");

     

       37
       37
        
       

     

       38
       38
        
           cache = mkOption {

     

       39
       39
        
             type = types.lines;

+1 -1

nixos/modules/services/web-servers/ttyd.nix

···

       30
       30
        
       

     

       31
       31
        
         options = {

     

       32
       32
        
           services.ttyd = {

     

       33
       33
       -
             enable = mkEnableOption "ttyd daemon";

     

       33
       33
       +
             enable = mkEnableOption (lib.mdDoc "ttyd daemon");

     

       34
       34
        
       

     

       35
       35
        
             port = mkOption {

     

       36
       36
        
               type = types.port;

+1 -1

nixos/modules/services/web-servers/unit/default.nix

···

       10
       10
        
       in {

     

       11
       11
        
         options = {

     

       12
       12
        
           services.unit = {

     

       13
       13
       -
             enable = mkEnableOption "Unit App Server";

     

       13
       13
       +
             enable = mkEnableOption (lib.mdDoc "Unit App Server");

     

       14
       14
        
             package = mkOption {

     

       15
       15
        
               type = types.package;

     

       16
       16
        
               default = pkgs.unit;

+2 -2

nixos/modules/services/web-servers/varnish/default.nix

···

       11
       11
        
       {

     

       12
       12
        
         options = {

     

       13
       13
        
           services.varnish = {

     

       14
       14
       -
             enable = mkEnableOption "Varnish Server";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "Varnish Server");

     

       15
       15
        
       

     

       16
       16
       -
             enableConfigCheck = mkEnableOption "checking the config during build time" // { default = true; };

     

       16
       16
       +
             enableConfigCheck = mkEnableOption (lib.mdDoc "checking the config during build time") // { default = true; };

     

       17
       17
        
       

     

       18
       18
        
             package = mkOption {

     

       19
       19
        
               type = types.package;

+1 -1

nixos/modules/services/x11/colord.nix

···

       11
       11
        
         options = {

     

       12
       12
        
       

     

       13
       13
        
           services.colord = {

     

       14
       14
       -
             enable = mkEnableOption "colord, the color management daemon";

     

       14
       14
       +
             enable = mkEnableOption (lib.mdDoc "colord, the color management daemon");

     

       15
       15
        
           };

     

       16
       16
        
       

     

       17
       17
        
         };

+1 -1

nixos/modules/services/x11/desktop-managers/cde.nix

···

       7
       7
        
         cfg = xcfg.desktopManager.cde;

     

       8
       8
        
       in {

     

       9
       9
        
         options.services.xserver.desktopManager.cde = {

     

       10
       10
       -
           enable = mkEnableOption "Common Desktop Environment";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "Common Desktop Environment");

     

       11
       11
        
       

     

       12
       12
        
           extraPackages = mkOption {

     

       13
       13
        
             type = with types; listOf package;

+2 -2

nixos/modules/services/x11/desktop-managers/cinnamon.nix

···

       17
       17
        
       {

     

       18
       18
        
         options = {

     

       19
       19
        
           services.cinnamon = {

     

       20
       20
       -
             apps.enable = mkEnableOption "Cinnamon default applications";

     

       20
       20
       +
             apps.enable = mkEnableOption (lib.mdDoc "Cinnamon default applications");

     

       21
       21
        
           };

     

       22
       22
        
       

     

       23
       23
        
           services.xserver.desktopManager.cinnamon = {

     

       24
       24
       -
             enable = mkEnableOption "the cinnamon desktop manager";

     

       24
       24
       +
             enable = mkEnableOption (lib.mdDoc "the cinnamon desktop manager");

     

       25
       25
        
       

     

       26
       26
        
             sessionPath = mkOption {

     

       27
       27
        
               default = [];

+2 -2

nixos/modules/services/x11/desktop-managers/default.nix

···

       86
       86
        
               type = types.nullOr types.str;

     

       87
       87
        
               default = null;

     

       88
       88
        
               example = "none";

     

       89
       89
       -
               description = ''

     

       90
       90
       -
                 <emphasis role="strong">Deprecated</emphasis>, please use <xref linkend="opt-services.xserver.displayManager.defaultSession"/> instead.

     

       89
       89
       +
               description = lib.mdDoc ''

     

       90
       90
       +
                 **Deprecated**, please use [](#opt-services.xserver.displayManager.defaultSession) instead.

     

       91
       91
        
       

     

       92
       92
        
                 Default desktop manager loaded if none have been chosen.

     

       93
       93
        
               '';

+7 -7

nixos/modules/services/x11/desktop-managers/gnome.nix

···

       165
       165
        
         options = {

     

       166
       166
        
       

     

       167
       167
        
           services.gnome = {

     

       168
       168
       -
             core-os-services.enable = mkEnableOption "essential services for GNOME3";

     

       169
       169
       -
             core-shell.enable = mkEnableOption "GNOME Shell services";

     

       170
       170
       -
             core-utilities.enable = mkEnableOption "GNOME core utilities";

     

       171
       171
       -
             core-developer-tools.enable = mkEnableOption "GNOME core developer tools";

     

       172
       172
       -
             games.enable = mkEnableOption "GNOME games";

     

       168
       168
       +
             core-os-services.enable = mkEnableOption (lib.mdDoc "essential services for GNOME3");

     

       169
       169
       +
             core-shell.enable = mkEnableOption (lib.mdDoc "GNOME Shell services");

     

       170
       170
       +
             core-utilities.enable = mkEnableOption (lib.mdDoc "GNOME core utilities");

     

       171
       171
       +
             core-developer-tools.enable = mkEnableOption (lib.mdDoc "GNOME core developer tools");

     

       172
       172
       +
             games.enable = mkEnableOption (lib.mdDoc "GNOME games");

     

       173
       173
        
           };

     

       174
       174
        
       

     

       175
       175
        
           services.xserver.desktopManager.gnome = {

     
···

       216
       216
        
               description = lib.mdDoc "List of packages for which gsettings are overridden.";

     

       217
       217
        
             };

     

       218
       218
        
       

     

       219
       219
       -
             debug = mkEnableOption "gnome-session debug messages";

     

       219
       219
       +
             debug = mkEnableOption (lib.mdDoc "gnome-session debug messages");

     

       220
       220
        
       

     

       221
       221
        
             flashback = {

     

       222
       222
       -
               enableMetacity = mkEnableOption "the standard GNOME Flashback session with Metacity";

     

       222
       222
       +
               enableMetacity = mkEnableOption (lib.mdDoc "the standard GNOME Flashback session with Metacity");

     

       223
       223
        
       

     

       224
       224
        
               customSessions = mkOption {

     

       225
       225
        
                 type = types.listOf (types.submodule {

+1 -1

nixos/modules/services/x11/desktop-managers/mate.nix

···

       19
       19
        
               description = lib.mdDoc "Enable the MATE desktop environment";

     

       20
       20
        
             };

     

       21
       21
        
       

     

       22
       22
       -
             debug = mkEnableOption "mate-session debug messages";

     

       22
       22
       +
             debug = mkEnableOption (lib.mdDoc "mate-session debug messages");

     

       23
       23
        
           };

     

       24
       24
        
       

     

       25
       25
        
           environment.mate.excludePackages = mkOption {

+3 -3

nixos/modules/services/x11/desktop-managers/pantheon.nix

···

       26
       26
        
           services.pantheon = {

     

       27
       27
        
       

     

       28
       28
        
             contractor = {

     

       29
       29
       -
                enable = mkEnableOption "contractor, a desktop-wide extension service used by Pantheon";

     

       29
       29
       +
                enable = mkEnableOption (lib.mdDoc "contractor, a desktop-wide extension service used by Pantheon");

     

       30
       30
        
             };

     

       31
       31
        
       

     

       32
       32
       -
             apps.enable = mkEnableOption "Pantheon default applications";

     

       32
       32
       +
             apps.enable = mkEnableOption (lib.mdDoc "Pantheon default applications");

     

       33
       33
        
       

     

       34
       34
        
           };

     

       35
       35
        
       

     
···

       76
       76
        
               description = lib.mdDoc "List of packages for which gsettings are overridden.";

     

       77
       77
        
             };

     

       78
       78
        
       

     

       79
       79
       -
             debug = mkEnableOption "gnome-session debug messages";

     

       79
       79
       +
             debug = mkEnableOption (lib.mdDoc "gnome-session debug messages");

     

       80
       80
        
       

     

       81
       81
        
           };

     

       82
       82

+1 -1

nixos/modules/services/x11/desktop-managers/retroarch.nix

···

       6
       6
        
       

     

       7
       7
        
       in {

     

       8
       8
        
         options.services.xserver.desktopManager.retroarch = {

     

       9
       9
       -
           enable = mkEnableOption "RetroArch";

     

       9
       9
       +
           enable = mkEnableOption (lib.mdDoc "RetroArch");

     

       10
       10
        
       

     

       11
       11
        
           package = mkOption {

     

       12
       12
        
             type = types.package;

+1 -1

nixos/modules/services/x11/desktop-managers/surf-display.nix

···

       45
       45
        
       in {

     

       46
       46
        
         options = {

     

       47
       47
        
           services.xserver.desktopManager.surf-display = {

     

       48
       48
       -
             enable = mkEnableOption "surf-display as a kiosk browser session";

     

       48
       48
       +
             enable = mkEnableOption (lib.mdDoc "surf-display as a kiosk browser session");

     

       49
       49
        
       

     

       50
       50
        
             defaultWwwUri = mkOption {

     

       51
       51
        
               type = types.str;

+4 -4

nixos/modules/services/x11/display-managers/default.nix

···

       235
       235
        
                     }

     

       236
       236
        
                   ]

     

       237
       237
        
                 '';

     

       238
       238
       -
               description = ''

     

       238
       238
       +
               description = lib.mdDoc ''

     

       239
       239
        
                 List of sessions supported with the command used to start each

     

       240
       240
        
                 session.  Each session script can set the

     

       241
       241
       -
                 <varname>waitPID</varname> shell variable to make this script

     

       241
       241
       +
                 {var}`waitPID` shell variable to make this script

     

       242
       242
        
                 wait until the end of the user session.  Each script is used

     

       243
       243
        
                 to define either a window manager or a desktop manager.  These

     

       244
       244
        
                 can be differentiated by setting the attribute

     

       245
       245
       -
                 <varname>manage</varname> either to <literal>"window"</literal>

     

       246
       246
       -
                 or <literal>"desktop"</literal>.

     

       245
       245
       +
                 {var}`manage` either to `"window"`

     

       246
       246
       +
                 or `"desktop"`.

     

       247
       247
        
       

     

       248
       248
        
                 The list of desktop manager and window manager should appear

     

       249
       249
        
                 inside the display manager with the desktop manager name

+2 -2

nixos/modules/services/x11/display-managers/gdm.nix

···

       67
       67
        
       

     

       68
       68
        
           services.xserver.displayManager.gdm = {

     

       69
       69
        
       

     

       70
       70
       -
             enable = mkEnableOption "GDM, the GNOME Display Manager";

     

       70
       70
       +
             enable = mkEnableOption (lib.mdDoc "GDM, the GNOME Display Manager");

     

       71
       71
        
       

     

       72
       72
       -
             debug = mkEnableOption "debugging messages in GDM";

     

       72
       72
       +
             debug = mkEnableOption (lib.mdDoc "debugging messages in GDM");

     

       73
       73
        
       

     

       74
       74
        
             # Auto login options specific to GDM

     

       75
       75
        
             autoLogin.delay = mkOption {

+2 -2

nixos/modules/services/x11/display-managers/lightdm-greeters/slick.nix

···

       25
       25
        
       {

     

       26
       26
        
         options = {

     

       27
       27
        
           services.xserver.displayManager.lightdm.greeters.slick = {

     

       28
       28
       -
             enable = mkEnableOption "lightdm-slick-greeter as the lightdm greeter";

     

       28
       28
       +
             enable = mkEnableOption (lib.mdDoc "lightdm-slick-greeter as the lightdm greeter");

     

       29
       29
        
       

     

       30
       30
        
             theme = {

     

       31
       31
        
               package = mkOption {

     
···

       84
       84
        
               };

     

       85
       85
        
             };

     

       86
       86
        
       

     

       87
       87
       -
             draw-user-backgrounds = mkEnableOption "draw user backgrounds";

     

       87
       87
       +
             draw-user-backgrounds = mkEnableOption (lib.mdDoc "draw user backgrounds");

     

       88
       88
        
       

     

       89
       89
        
             extraConfig = mkOption {

     

       90
       90
        
               type = types.lines;

+1 -1

nixos/modules/services/x11/display-managers/xpra.nix

···

       40
       40
        
               description = lib.mdDoc "Authentication to use when connecting to xpra";

     

       41
       41
        
             };

     

       42
       42
        
       

     

       43
       43
       -
             pulseaudio = mkEnableOption "pulseaudio audio streaming";

     

       43
       43
       +
             pulseaudio = mkEnableOption (lib.mdDoc "pulseaudio audio streaming");

     

       44
       44
        
       

     

       45
       45
        
             extraOptions = mkOption {

     

       46
       46
        
               description = lib.mdDoc "Extra xpra options";

+1 -1

nixos/modules/services/x11/hardware/digimend.nix

···

       16
       16
        
       

     

       17
       17
        
           services.xserver.digimend = {

     

       18
       18
        
       

     

       19
       19
       -
             enable = mkEnableOption "the digimend drivers for Huion/XP-Pen/etc. tablets";

     

       19
       19
       +
             enable = mkEnableOption (lib.mdDoc "the digimend drivers for Huion/XP-Pen/etc. tablets");

     

       20
       20
        
       

     

       21
       21
        
           };

     

       22
       22

+1 -1

nixos/modules/services/x11/hardware/libinput.nix

···

       250
       250
        
         options = {

     

       251
       251
        
       

     

       252
       252
        
           services.xserver.libinput = {

     

       253
       253
       -
             enable = mkEnableOption "libinput";

     

       253
       253
       +
             enable = mkEnableOption (lib.mdDoc "libinput");

     

       254
       254
        
             mouse = mkConfigForDevice "mouse";

     

       255
       255
        
             touchpad = mkConfigForDevice "touchpad";

     

       256
       256
        
           };

+1 -1

nixos/modules/services/x11/imwheel.nix

···

       6
       6
        
         {

     

       7
       7
        
           options = {

     

       8
       8
        
             services.xserver.imwheel = {

     

       9
       9
       -
               enable = mkEnableOption "IMWheel service";

     

       9
       9
       +
               enable = mkEnableOption (lib.mdDoc "IMWheel service");

     

       10
       10
        
       

     

       11
       11
        
               extraOptions = mkOption {

     

       12
       12
        
                 type = types.listOf types.str;

+1 -1

nixos/modules/services/x11/touchegg.nix

···

       11
       11
        
       

     

       12
       12
        
         ###### interface

     

       13
       13
        
         options.services.touchegg = {

     

       14
       14
       -
           enable = mkEnableOption "touchegg, a multi-touch gesture recognizer";

     

       14
       14
       +
           enable = mkEnableOption (lib.mdDoc "touchegg, a multi-touch gesture recognizer");

     

       15
       15
        
       

     

       16
       16
        
           package = mkOption {

     

       17
       17
        
             type = types.package;

+1 -1

nixos/modules/services/x11/urserver.nix

···

       5
       5
        
         cfg = config.services.urserver;

     

       6
       6
        
       in {

     

       7
       7
        
       

     

       8
       8
       -
         options.services.urserver.enable = lib.mkEnableOption "urserver";

     

       8
       8
       +
         options.services.urserver.enable = lib.mkEnableOption (lib.mdDoc "urserver");

     

       9
       9
        
       

     

       10
       10
        
         config = lib.mkIf cfg.enable {

     

       11
       11

+1 -1

nixos/modules/services/x11/window-managers/2bwm.nix

···

       13
       13
        
         ###### interface

     

       14
       14
        
       

     

       15
       15
        
         options = {

     

       16
       16
       -
           services.xserver.windowManager."2bwm".enable = mkEnableOption "2bwm";

     

       16
       16
       +
           services.xserver.windowManager."2bwm".enable = mkEnableOption (lib.mdDoc "2bwm");

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19

+1 -1

nixos/modules/services/x11/window-managers/afterstep.nix

···

       8
       8
        
       {

     

       9
       9
        
         ###### interface

     

       10
       10
        
         options = {

     

       11
       11
       -
           services.xserver.windowManager.afterstep.enable = mkEnableOption "afterstep";

     

       11
       11
       +
           services.xserver.windowManager.afterstep.enable = mkEnableOption (lib.mdDoc "afterstep");

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         ###### implementation

+1 -1

nixos/modules/services/x11/window-managers/awesome.nix

···

       21
       21
        
       

     

       22
       22
        
           services.xserver.windowManager.awesome = {

     

       23
       23
        
       

     

       24
       24
       -
             enable = mkEnableOption "Awesome window manager";

     

       24
       24
       +
             enable = mkEnableOption (lib.mdDoc "Awesome window manager");

     

       25
       25
        
       

     

       26
       26
        
             luaModules = mkOption {

     

       27
       27
        
               default = [];

+1 -1

nixos/modules/services/x11/window-managers/berry.nix

···

       8
       8
        
       {

     

       9
       9
        
         ###### interface

     

       10
       10
        
         options = {

     

       11
       11
       -
           services.xserver.windowManager.berry.enable = mkEnableOption "berry";

     

       11
       11
       +
           services.xserver.windowManager.berry.enable = mkEnableOption (lib.mdDoc "berry");

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         ###### implementation

+1 -1

nixos/modules/services/x11/window-managers/bspwm.nix

···

       9
       9
        
       {

     

       10
       10
        
         options = {

     

       11
       11
        
           services.xserver.windowManager.bspwm = {

     

       12
       12
       -
             enable = mkEnableOption "bspwm";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "bspwm");

     

       13
       13
        
       

     

       14
       14
        
             package = mkOption {

     

       15
       15
        
               type        = types.package;

+1 -1

nixos/modules/services/x11/window-managers/clfswm.nix

···

       9
       9
        
       {

     

       10
       10
        
         options = {

     

       11
       11
        
           services.xserver.windowManager.clfswm = {

     

       12
       12
       -
             enable = mkEnableOption "clfswm";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "clfswm");

     

       13
       13
        
             package = mkOption {

     

       14
       14
        
               type        = types.package;

     

       15
       15
        
               default     = pkgs.lispPackages.clfswm;

+1 -1

nixos/modules/services/x11/window-managers/cwm.nix

···

       7
       7
        
       in

     

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
       -
           services.xserver.windowManager.cwm.enable = mkEnableOption "cwm";

     

       10
       10
       +
           services.xserver.windowManager.cwm.enable = mkEnableOption (lib.mdDoc "cwm");

     

       11
       11
        
         };

     

       12
       12
        
         config = mkIf cfg.enable {

     

       13
       13
        
           services.xserver.windowManager.session = singleton

+2 -2

nixos/modules/services/x11/window-managers/default.nix

···

       73
       73
        
               type = types.nullOr types.str;

     

       74
       74
        
               default = null;

     

       75
       75
        
               example = "wmii";

     

       76
       76
       -
               description = ''

     

       77
       77
       -
                 <emphasis role="strong">Deprecated</emphasis>, please use <xref linkend="opt-services.xserver.displayManager.defaultSession"/> instead.

     

       76
       76
       +
               description = lib.mdDoc ''

     

       77
       77
       +
                 **Deprecated**, please use [](#opt-services.xserver.displayManager.defaultSession) instead.

     

       78
       78
        
       

     

       79
       79
        
                 Default window manager loaded if none have been chosen.

     

       80
       80
        
               '';

+1 -1

nixos/modules/services/x11/window-managers/dwm.nix

···

       13
       13
        
         ###### interface

     

       14
       14
        
       

     

       15
       15
        
         options = {

     

       16
       16
       -
           services.xserver.windowManager.dwm.enable = mkEnableOption "dwm";

     

       16
       16
       +
           services.xserver.windowManager.dwm.enable = mkEnableOption (lib.mdDoc "dwm");

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19

+1 -1

nixos/modules/services/x11/window-managers/e16.nix

···

       8
       8
        
       {

     

       9
       9
        
         ###### interface

     

       10
       10
        
         options = {

     

       11
       11
       -
           services.xserver.windowManager.e16.enable = mkEnableOption "e16";

     

       11
       11
       +
           services.xserver.windowManager.e16.enable = mkEnableOption (lib.mdDoc "e16");

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         ###### implementation

+1 -1

nixos/modules/services/x11/window-managers/evilwm.nix

···

       8
       8
        
       {

     

       9
       9
        
         ###### interface

     

       10
       10
        
         options = {

     

       11
       11
       -
           services.xserver.windowManager.evilwm.enable = mkEnableOption "evilwm";

     

       11
       11
       +
           services.xserver.windowManager.evilwm.enable = mkEnableOption (lib.mdDoc "evilwm");

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         ###### implementation

+3 -3

nixos/modules/services/x11/window-managers/exwm.nix

···

       18
       18
        
       {

     

       19
       19
        
         options = {

     

       20
       20
        
           services.xserver.windowManager.exwm = {

     

       21
       21
       -
             enable = mkEnableOption "exwm";

     

       21
       21
       +
             enable = mkEnableOption (lib.mdDoc "exwm");

     

       22
       22
        
             loadScript = mkOption {

     

       23
       23
        
               default = "(require 'exwm)";

     

       24
       24
        
               type = types.lines;

     
···

       48
       48
        
                   epkgs.proofgeneral

     

       49
       49
        
                 ]

     

       50
       50
        
               '';

     

       51
       51
       -
               description = ''

     

       51
       51
       +
               description = lib.mdDoc ''

     

       52
       52
        
                 Extra packages available to Emacs. The value must be a

     

       53
       53
        
                 function which receives the attrset defined in

     

       54
       54
       -
                 <varname>emacs.pkgs</varname> as the sole argument.

     

       54
       54
       +
                 {var}`emacs.pkgs` as the sole argument.

     

       55
       55
        
               '';

     

       56
       56
        
             };

     

       57
       57
        
           };

+1 -1

nixos/modules/services/x11/window-managers/fluxbox.nix

···

       8
       8
        
       {

     

       9
       9
        
         ###### interface

     

       10
       10
        
         options = {

     

       11
       11
       -
           services.xserver.windowManager.fluxbox.enable = mkEnableOption "fluxbox";

     

       11
       11
       +
           services.xserver.windowManager.fluxbox.enable = mkEnableOption (lib.mdDoc "fluxbox");

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         ###### implementation

+1 -1

nixos/modules/services/x11/window-managers/fvwm2.nix

···

       19
       19
        
       

     

       20
       20
        
         options = {

     

       21
       21
        
           services.xserver.windowManager.fvwm2 = {

     

       22
       22
       -
             enable = mkEnableOption "Fvwm2 window manager";

     

       22
       22
       +
             enable = mkEnableOption (lib.mdDoc "Fvwm2 window manager");

     

       23
       23
        
       

     

       24
       24
        
             gestures = mkOption {

     

       25
       25
        
               default = false;

+1 -1

nixos/modules/services/x11/window-managers/fvwm3.nix

···

       13
       13
        
       

     

       14
       14
        
         options = {

     

       15
       15
        
           services.xserver.windowManager.fvwm3 = {

     

       16
       16
       -
             enable = mkEnableOption "Fvwm3 window manager";

     

       16
       16
       +
             enable = mkEnableOption (lib.mdDoc "Fvwm3 window manager");

     

       17
       17
        
           };

     

       18
       18
        
         };

     

       19
       19

+1 -1

nixos/modules/services/x11/window-managers/hackedbox.nix

···

       8
       8
        
       {

     

       9
       9
        
         ###### interface

     

       10
       10
        
         options = {

     

       11
       11
       -
           services.xserver.windowManager.hackedbox.enable = mkEnableOption "hackedbox";

     

       11
       11
       +
           services.xserver.windowManager.hackedbox.enable = mkEnableOption (lib.mdDoc "hackedbox");

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         ###### implementation

+1 -1

nixos/modules/services/x11/window-managers/herbstluftwm.nix

···

       9
       9
        
       {

     

       10
       10
        
         options = {

     

       11
       11
        
           services.xserver.windowManager.herbstluftwm = {

     

       12
       12
       -
             enable = mkEnableOption "herbstluftwm";

     

       12
       12
       +
             enable = mkEnableOption (lib.mdDoc "herbstluftwm");

     

       13
       13
        
       

     

       14
       14
        
             package = mkOption {

     

       15
       15
        
               type = types.package;

+1 -1

nixos/modules/services/x11/window-managers/i3.nix

···

       8
       8
        
       

     

       9
       9
        
       {

     

       10
       10
        
         options.services.xserver.windowManager.i3 = {

     

       11
       11
       -
           enable = mkEnableOption "i3 window manager";

     

       11
       11
       +
           enable = mkEnableOption (lib.mdDoc "i3 window manager");

     

       12
       12
        
       

     

       13
       13
        
           configFile = mkOption {

     

       14
       14
        
             default     = null;

+1 -1

nixos/modules/services/x11/window-managers/icewm.nix

···

       8
       8
        
       {

     

       9
       9
        
         ###### interface

     

       10
       10
        
         options = {

     

       11
       11
       -
           services.xserver.windowManager.icewm.enable = mkEnableOption "icewm";

     

       11
       11
       +
           services.xserver.windowManager.icewm.enable = mkEnableOption (lib.mdDoc "icewm");

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         ###### implementation

+1 -1

nixos/modules/services/x11/window-managers/jwm.nix

···

       8
       8
        
       {

     

       9
       9
        
         ###### interface

     

       10
       10
        
         options = {

     

       11
       11
       -
           services.xserver.windowManager.jwm.enable = mkEnableOption "jwm";

     

       11
       11
       +
           services.xserver.windowManager.jwm.enable = mkEnableOption (lib.mdDoc "jwm");

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         ###### implementation

+1 -1

nixos/modules/services/x11/window-managers/leftwm.nix

···

       8
       8
        
       {

     

       9
       9
        
         ###### interface

     

       10
       10
        
         options = {

     

       11
       11
       -
           services.xserver.windowManager.leftwm.enable = mkEnableOption "leftwm";

     

       11
       11
       +
           services.xserver.windowManager.leftwm.enable = mkEnableOption (lib.mdDoc "leftwm");

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         ###### implementation

+1 -1

nixos/modules/services/x11/window-managers/lwm.nix

···

       8
       8
        
       {

     

       9
       9
        
         ###### interface

     

       10
       10
        
         options = {

     

       11
       11
       -
           services.xserver.windowManager.lwm.enable = mkEnableOption "lwm";

     

       11
       11
       +
           services.xserver.windowManager.lwm.enable = mkEnableOption (lib.mdDoc "lwm");

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         ###### implementation

+1 -1

nixos/modules/services/x11/window-managers/metacity.nix

···

       10
       10
        
       

     

       11
       11
        
       {

     

       12
       12
        
         options = {

     

       13
       13
       -
           services.xserver.windowManager.metacity.enable = mkEnableOption "metacity";

     

       13
       13
       +
           services.xserver.windowManager.metacity.enable = mkEnableOption (lib.mdDoc "metacity");

     

       14
       14
        
         };

     

       15
       15
        
       

     

       16
       16
        
         config = mkIf cfg.enable {

+1 -1

nixos/modules/services/x11/window-managers/mlvwm.nix

···

       8
       8
        
       {

     

       9
       9
        
       

     

       10
       10
        
         options.services.xserver.windowManager.mlvwm = {

     

       11
       11
       -
           enable = mkEnableOption "Macintosh-like Virtual Window Manager";

     

       11
       11
       +
           enable = mkEnableOption (lib.mdDoc "Macintosh-like Virtual Window Manager");

     

       12
       12
        
       

     

       13
       13
        
           configFile = mkOption {

     

       14
       14
        
             default = null;

+1 -1

nixos/modules/services/x11/window-managers/mwm.nix

···

       8
       8
        
       {

     

       9
       9
        
         ###### interface

     

       10
       10
        
         options = {

     

       11
       11
       -
           services.xserver.windowManager.mwm.enable = mkEnableOption "mwm";

     

       11
       11
       +
           services.xserver.windowManager.mwm.enable = mkEnableOption (lib.mdDoc "mwm");

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         ###### implementation

+1 -1

nixos/modules/services/x11/window-managers/notion.nix

···

       8
       8
        
       

     

       9
       9
        
       {

     

       10
       10
        
         options = {

     

       11
       11
       -
           services.xserver.windowManager.notion.enable = mkEnableOption "notion";

     

       11
       11
       +
           services.xserver.windowManager.notion.enable = mkEnableOption (lib.mdDoc "notion");

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         config = mkIf cfg.enable {

+1 -1

nixos/modules/services/x11/window-managers/openbox.nix

···

       7
       7
        
       

     

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
       -
           services.xserver.windowManager.openbox.enable = mkEnableOption "openbox";

     

       10
       10
       +
           services.xserver.windowManager.openbox.enable = mkEnableOption (lib.mdDoc "openbox");

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         config = mkIf cfg.enable {

+1 -1

nixos/modules/services/x11/window-managers/oroborus.nix

···

       8
       8
        
       {

     

       9
       9
        
         ###### interface

     

       10
       10
        
         options = {

     

       11
       11
       -
           services.xserver.windowManager.oroborus.enable = mkEnableOption "oroborus";

     

       11
       11
       +
           services.xserver.windowManager.oroborus.enable = mkEnableOption (lib.mdDoc "oroborus");

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         ###### implementation

+1 -1

nixos/modules/services/x11/window-managers/pekwm.nix

···

       8
       8
        
       {

     

       9
       9
        
         ###### interface

     

       10
       10
        
         options = {

     

       11
       11
       -
           services.xserver.windowManager.pekwm.enable = mkEnableOption "pekwm";

     

       11
       11
       +
           services.xserver.windowManager.pekwm.enable = mkEnableOption (lib.mdDoc "pekwm");

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         ###### implementation

+1 -1

nixos/modules/services/x11/window-managers/qtile.nix

···

       8
       8
        
       

     

       9
       9
        
       {

     

       10
       10
        
         options.services.xserver.windowManager.qtile = {

     

       11
       11
       -
           enable = mkEnableOption "qtile";

     

       11
       11
       +
           enable = mkEnableOption (lib.mdDoc "qtile");

     

       12
       12
        
       

     

       13
       13
        
           package = mkPackageOption pkgs "qtile" { };

     

       14
       14
        
         };

+1 -1

nixos/modules/services/x11/window-managers/ratpoison.nix

···

       8
       8
        
       {

     

       9
       9
        
         ###### interface

     

       10
       10
        
         options = {

     

       11
       11
       -
           services.xserver.windowManager.ratpoison.enable = mkEnableOption "ratpoison";

     

       11
       11
       +
           services.xserver.windowManager.ratpoison.enable = mkEnableOption (lib.mdDoc "ratpoison");

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         ###### implementation

+1 -1

nixos/modules/services/x11/window-managers/sawfish.nix

···

       8
       8
        
       {

     

       9
       9
        
         ###### interface

     

       10
       10
        
         options = {

     

       11
       11
       -
           services.xserver.windowManager.sawfish.enable = mkEnableOption "sawfish";

     

       11
       11
       +
           services.xserver.windowManager.sawfish.enable = mkEnableOption (lib.mdDoc "sawfish");

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         ###### implementation

+1 -1

nixos/modules/services/x11/window-managers/smallwm.nix

···

       8
       8
        
       {

     

       9
       9
        
         ###### interface

     

       10
       10
        
         options = {

     

       11
       11
       -
           services.xserver.windowManager.smallwm.enable = mkEnableOption "smallwm";

     

       11
       11
       +
           services.xserver.windowManager.smallwm.enable = mkEnableOption (lib.mdDoc "smallwm");

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         ###### implementation

+1 -1

nixos/modules/services/x11/window-managers/spectrwm.nix

···

       9
       9
        
       

     

       10
       10
        
       {

     

       11
       11
        
         options = {

     

       12
       12
       -
           services.xserver.windowManager.spectrwm.enable = mkEnableOption "spectrwm";

     

       12
       12
       +
           services.xserver.windowManager.spectrwm.enable = mkEnableOption (lib.mdDoc "spectrwm");

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         config = mkIf cfg.enable {

+1 -1

nixos/modules/services/x11/window-managers/stumpwm.nix

···

       8
       8
        
       

     

       9
       9
        
       {

     

       10
       10
        
         options = {

     

       11
       11
       -
           services.xserver.windowManager.stumpwm.enable = mkEnableOption "stumpwm";

     

       11
       11
       +
           services.xserver.windowManager.stumpwm.enable = mkEnableOption (lib.mdDoc "stumpwm");

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         config = mkIf cfg.enable {

+1 -1

nixos/modules/services/x11/window-managers/tinywm.nix

···

       8
       8
        
       {

     

       9
       9
        
         ###### interface

     

       10
       10
        
         options = {

     

       11
       11
       -
           services.xserver.windowManager.tinywm.enable = mkEnableOption "tinywm";

     

       11
       11
       +
           services.xserver.windowManager.tinywm.enable = mkEnableOption (lib.mdDoc "tinywm");

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         ###### implementation

+1 -1

nixos/modules/services/x11/window-managers/twm.nix

···

       13
       13
        
         ###### interface

     

       14
       14
        
       

     

       15
       15
        
         options = {

     

       16
       16
       -
           services.xserver.windowManager.twm.enable = mkEnableOption "twm";

     

       16
       16
       +
           services.xserver.windowManager.twm.enable = mkEnableOption (lib.mdDoc "twm");

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19

+1 -1

nixos/modules/services/x11/window-managers/windowlab.nix

···

       7
       7
        
       {

     

       8
       8
        
         options = {

     

       9
       9
        
           services.xserver.windowManager.windowlab.enable =

     

       10
       10
       -
             lib.mkEnableOption "windowlab";

     

       10
       10
       +
             lib.mkEnableOption (lib.mdDoc "windowlab");

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         config = lib.mkIf cfg.enable {

+1 -1

nixos/modules/services/x11/window-managers/windowmaker.nix

···

       8
       8
        
       {

     

       9
       9
        
         ###### interface

     

       10
       10
        
         options = {

     

       11
       11
       -
           services.xserver.windowManager.windowmaker.enable = mkEnableOption "windowmaker";

     

       11
       11
       +
           services.xserver.windowManager.windowmaker.enable = mkEnableOption (lib.mdDoc "windowmaker");

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         ###### implementation

+1 -1

nixos/modules/services/x11/window-managers/wmderland.nix

···

       8
       8
        
       

     

       9
       9
        
       {

     

       10
       10
        
         options.services.xserver.windowManager.wmderland = {

     

       11
       11
       -
           enable = mkEnableOption "wmderland";

     

       11
       11
       +
           enable = mkEnableOption (lib.mdDoc "wmderland");

     

       12
       12
        
       

     

       13
       13
        
           extraSessionCommands = mkOption {

     

       14
       14
        
             default = "";

+1 -1

nixos/modules/services/x11/window-managers/wmii.nix

···

       7
       7
        
       in

     

       8
       8
        
       {

     

       9
       9
        
         options = {

     

       10
       10
       -
           services.xserver.windowManager.wmii.enable = mkEnableOption "wmii";

     

       10
       10
       +
           services.xserver.windowManager.wmii.enable = mkEnableOption (lib.mdDoc "wmii");

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         config = mkIf cfg.enable {

+5 -5

nixos/modules/services/x11/window-managers/xmonad.nix

···

       41
       41
        
       

     

       42
       42
        
         options = {

     

       43
       43
        
           services.xserver.windowManager.xmonad = {

     

       44
       44
       -
             enable = mkEnableOption "xmonad";

     

       44
       44
       +
             enable = mkEnableOption (lib.mdDoc "xmonad");

     

       45
       45
        
       

     

       46
       46
        
             haskellPackages = mkOption {

     

       47
       47
        
               default = pkgs.haskellPackages;

     

       48
       48
        
               defaultText = literalExpression "pkgs.haskellPackages";

     

       49
       49
        
               example = literalExpression "pkgs.haskell.packages.ghc8107";

     

       50
       50
        
               type = types.attrs;

     

       51
       51
       -
               description = ''

     

       51
       51
       +
               description = lib.mdDoc ''

     

       52
       52
        
                 haskellPackages used to build Xmonad and other packages.

     

       53
       53
        
                 This can be used to change the GHC version used to build

     

       54
       54
        
                 Xmonad and the packages listed in

     

       55
       55
       -
                 <varname>extraPackages</varname>.

     

       55
       55
       +
                 {var}`extraPackages`.

     

       56
       56
        
               '';

     

       57
       57
        
             };

     

       58
       58
        
       

     
···

       66
       66
        
                   haskellPackages.monad-logger

     

       67
       67
        
                 ]

     

       68
       68
        
               '';

     

       69
       69
       -
               description = ''

     

       69
       69
       +
               description = lib.mdDoc ''

     

       70
       70
        
                 Extra packages available to ghc when rebuilding Xmonad. The

     

       71
       71
        
                 value must be a function which receives the attrset defined

     

       72
       72
       -
                 in <varname>haskellPackages</varname> as the sole argument.

     

       72
       72
       +
                 in {var}`haskellPackages` as the sole argument.

     

       73
       73
        
               '';

     

       74
       74
        
             };

     

       75
       75

+1 -1

nixos/modules/services/x11/window-managers/yeahwm.nix

···

       8
       8
        
       {

     

       9
       9
        
         ###### interface

     

       10
       10
        
         options = {

     

       11
       11
       -
           services.xserver.windowManager.yeahwm.enable = mkEnableOption "yeahwm";

     

       11
       11
       +
           services.xserver.windowManager.yeahwm.enable = mkEnableOption (lib.mdDoc "yeahwm");

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         ###### implementation

+1 -1

nixos/modules/services/x11/xautolock.nix

···

       8
       8
        
         {

     

       9
       9
        
           options = {

     

       10
       10
        
             services.xserver.xautolock = {

     

       11
       11
       -
               enable = mkEnableOption "xautolock";

     

       11
       11
       +
               enable = mkEnableOption (lib.mdDoc "xautolock");

     

       12
       12
        
               enableNotifier = mkEnableOption "xautolock.notify" // {

     

       13
       13
        
                 description = ''

     

       14
       14
        
                   Whether to enable the notifier feature of xautolock.

+1 -1

nixos/modules/services/x11/xbanish.nix

···

       7
       7
        
       in {

     

       8
       8
        
         options.services.xbanish = {

     

       9
       9
        
       

     

       10
       10
       -
           enable = mkEnableOption "xbanish";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "xbanish");

     

       11
       11
        
       

     

       12
       12
        
           arguments = mkOption {

     

       13
       13
        
             description = lib.mdDoc "Arguments to pass to xbanish command";

+1 -1

nixos/modules/system/boot/grow-partition.nix

···

       12
       12
        
         ];

     

       13
       13
        
       

     

       14
       14
        
         options = {

     

       15
       15
       -
           boot.growPartition = mkEnableOption "grow the root partition on boot";

     

       15
       15
       +
           boot.growPartition = mkEnableOption (lib.mdDoc "grow the root partition on boot");

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
        
         config = mkIf config.boot.growPartition {

+6 -6

nixos/modules/system/boot/kernel.nix

···

       48
       48
        
             # - some of it might not even evaluate correctly.

     

       49
       49
        
             defaultText = literalExpression "pkgs.linuxPackages";

     

       50
       50
        
             example = literalExpression "pkgs.linuxKernel.packages.linux_5_10";

     

       51
       51
       -
             description = ''

     

       51
       51
       +
             description = lib.mdDoc ''

     

       52
       52
        
               This option allows you to override the Linux kernel used by

     

       53
       53
        
               NixOS.  Since things like external kernel module packages are

     

       54
       54
        
               tied to the kernel you're using, it also overrides those.

     

       55
       55
        
               This option is a function that takes Nixpkgs as an argument

     

       56
       56
        
               (as a convenience), and returns an attribute set containing at

     

       57
       57
       -
               the very least an attribute <varname>kernel</varname>.

     

       57
       57
       +
               the very least an attribute {var}`kernel`.

     

       58
       58
        
               Additional attributes may be needed depending on your

     

       59
       59
        
               configuration.  For instance, if you use the NVIDIA X driver,

     

       60
       60
        
               then it also needs to contain an attribute

     

       61
       61
       -
               <varname>nvidia_x11</varname>.

     

       61
       61
       +
               {var}`nvidia_x11`.

     

       62
       62
        
             '';

     

       63
       63
        
           };

     

       64
       64
        
       

     
···

       73
       73
        
             type = types.str;

     

       74
       74
        
             default = "";

     

       75
       75
        
             example = "my secret seed";

     

       76
       76
       -
             description = ''

     

       77
       77
       -
               Provides a custom seed for the <varname>RANDSTRUCT</varname> security

     

       78
       78
       -
               option of the Linux kernel. Note that <varname>RANDSTRUCT</varname> is

     

       76
       76
       +
             description = lib.mdDoc ''

     

       77
       77
       +
               Provides a custom seed for the {var}`RANDSTRUCT` security

     

       78
       78
       +
               option of the Linux kernel. Note that {var}`RANDSTRUCT` is

     

       79
       79
        
               only enabled in NixOS hardened kernels. Using a custom seed requires

     

       80
       80
        
               building the kernel and dependent packages locally, since this

     

       81
       81
        
               customization happens at build time.

+1 -1

nixos/modules/system/boot/plymouth.nix

···

       62
       62
        
       

     

       63
       63
        
           boot.plymouth = {

     

       64
       64
        
       

     

       65
       65
       -
             enable = mkEnableOption "Plymouth boot splash screen";

     

       65
       65
       +
             enable = mkEnableOption (lib.mdDoc "Plymouth boot splash screen");

     

       66
       66
        
       

     

       67
       67
        
             font = mkOption {

     

       68
       68
        
               default = "${pkgs.dejavu_fonts.minimal}/share/fonts/truetype/DejaVuSans.ttf";

+3 -3

nixos/modules/system/boot/stage-1.nix

···

       475
       475
        
             type = types.str;

     

       476
       476
        
             default = "";

     

       477
       477
        
             example = "/dev/sda3";

     

       478
       478
       -
             description = ''

     

       478
       478
       +
             description = lib.mdDoc ''

     

       479
       479
        
               Device for manual resume attempt during boot. This should be used primarily

     

       480
       480
        
               if you want to resume from file. If left empty, the swap partitions are used.

     

       481
       481
        
               Specify here the device where the file resides.

     

       482
       482
       -
               You should also use <varname>boot.kernelParams</varname> to specify

     

       483
       483
       -
               <literal>«resume_offset»</literal>.

     

       482
       482
       +
               You should also use {var}`boot.kernelParams` to specify

     

       483
       483
       +
               `«resume_offset»`.

     

       484
       484
        
             '';

     

       485
       485
        
           };

     

       486
       486

+1 -1

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

···

       9
       9
        
       

     

       10
       10
        
       in {

     

       11
       11
        
         options.systemd.shutdownRamfs = {

     

       12
       12
       -
           enable = lib.mkEnableOption "pivoting back to an initramfs for shutdown" // { default = true; };

     

       12
       12
       +
           enable = lib.mkEnableOption (lib.mdDoc "pivoting back to an initramfs for shutdown") // { default = true; };

     

       13
       13
        
           contents = lib.mkOption {

     

       14
       14
        
             description = lib.mdDoc "Set of files that have to be linked into the shutdown ramfs";

     

       15
       15
        
             example = lib.literalExpression ''

+1 -1

nixos/modules/tasks/filesystems/btrfs.nix

···

       19
       19
        
           # One could also do regular btrfs balances, but that shouldn't be necessary

     

       20
       20
        
           # during normal usage and as long as the filesystems aren't filled near capacity

     

       21
       21
        
           services.btrfs.autoScrub = {

     

       22
       22
       -
             enable = mkEnableOption "regular btrfs scrub";

     

       22
       22
       +
             enable = mkEnableOption (lib.mdDoc "regular btrfs scrub");

     

       23
       23
        
       

     

       24
       24
        
             fileSystems = mkOption {

     

       25
       25
        
               type = types.listOf types.path;

+5 -5

nixos/modules/tasks/filesystems/zfs.nix

···

       277
       277
        
             forceImportAll = mkOption {

     

       278
       278
        
               type = types.bool;

     

       279
       279
        
               default = false;

     

       280
       280
       -
               description = ''

     

       280
       280
       +
               description = lib.mdDoc ''

     

       281
       281
        
                 Forcibly import all ZFS pool(s).

     

       282
       282
        
       

     

       283
       283
       -
                 If you set this option to <literal>false</literal> and NixOS subsequently fails to

     

       283
       283
       +
                 If you set this option to `false` and NixOS subsequently fails to

     

       284
       284
        
                 import your non-root ZFS pool(s), you should manually import each pool with

     

       285
       285
       -
                 "zpool import -f &lt;pool-name&gt;", and then reboot. You should only need to do

     

       285
       285
       +
                 "zpool import -f \<pool-name\>", and then reboot. You should only need to do

     

       286
       286
        
                 this once.

     

       287
       287
        
               '';

     

       288
       288
        
             };

     
···

       399
       399
        
           };

     

       400
       400
        
       

     

       401
       401
        
           services.zfs.autoScrub = {

     

       402
       402
       -
             enable = mkEnableOption "periodic scrubbing of ZFS pools";

     

       402
       402
       +
             enable = mkEnableOption (lib.mdDoc "periodic scrubbing of ZFS pools");

     

       403
       403
        
       

     

       404
       404
        
             interval = mkOption {

     

       405
       405
        
               default = "Sun, 02:00";

     
···

       440
       440
        
           };

     

       441
       441
        
       

     

       442
       442
        
           services.zfs.zed = {

     

       443
       443
       -
             enableMail = mkEnableOption "ZED's ability to send emails" // {

     

       443
       443
       +
             enableMail = mkEnableOption (lib.mdDoc "ZED's ability to send emails") // {

     

       444
       444
        
               default = cfgZfs.package.enableMail;

     

       445
       445
        
               defaultText = literalExpression "config.${optZfs.package}.enableMail";

     

       446
       446
        
             };

+3 -3

nixos/modules/tasks/lvm.nix

···

       16
       16
        
               Defaults to pkgs.lvm2, pkgs.lvm2_dmeventd if dmeventd or pkgs.lvm2_vdo if vdo is enabled.

     

       17
       17
        
             '';

     

       18
       18
        
           };

     

       19
       19
       -
           dmeventd.enable = mkEnableOption "the LVM dmevent daemon";

     

       20
       20
       -
           boot.thin.enable = mkEnableOption "support for booting from ThinLVs";

     

       21
       21
       -
           boot.vdo.enable = mkEnableOption "support for booting from VDOLVs";

     

       19
       19
       +
           dmeventd.enable = mkEnableOption (lib.mdDoc "the LVM dmevent daemon");

     

       20
       20
       +
           boot.thin.enable = mkEnableOption (lib.mdDoc "support for booting from ThinLVs");

     

       21
       21
       +
           boot.vdo.enable = mkEnableOption (lib.mdDoc "support for booting from VDOLVs");

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
        
         options.boot.initrd.services.lvm.enable = (mkEnableOption "enable booting from LVM2 in the initrd") // {

+1 -1

nixos/modules/tasks/powertop.nix

···

       7
       7
        
       in {

     

       8
       8
        
         ###### interface

     

       9
       9
        
       

     

       10
       10
       -
         options.powerManagement.powertop.enable = mkEnableOption "powertop auto tuning on startup";

     

       10
       10
       +
         options.powerManagement.powertop.enable = mkEnableOption (lib.mdDoc "powertop auto tuning on startup");

     

       11
       11
        
       

     

       12
       12
        
         ###### implementation

     

       13
       13

+1 -1

nixos/modules/tasks/snapraid.nix

···

       6
       6
        
       in

     

       7
       7
        
       {

     

       8
       8
        
         options.snapraid = with types; {

     

       9
       9
       -
           enable = mkEnableOption "SnapRAID";

     

       9
       9
       +
           enable = mkEnableOption (lib.mdDoc "SnapRAID");

     

       10
       10
        
           dataDisks = mkOption {

     

       11
       11
        
             default = { };

     

       12
       12
        
             example = {

+1 -1

nixos/modules/virtualisation/anbox.nix

···

       31
       31
        
       

     

       32
       32
        
         options.virtualisation.anbox = {

     

       33
       33
        
       

     

       34
       34
       -
           enable = mkEnableOption "Anbox";

     

       34
       34
       +
           enable = mkEnableOption (lib.mdDoc "Anbox");

     

       35
       35
        
       

     

       36
       36
        
           image = mkOption {

     

       37
       37
        
             default = pkgs.anbox.image;

+1 -1

nixos/modules/virtualisation/containerd.nix

···

       19
       19
        
       {

     

       20
       20
        
       

     

       21
       21
        
         options.virtualisation.containerd = with lib.types; {

     

       22
       22
       -
           enable = lib.mkEnableOption "containerd container runtime";

     

       22
       22
       +
           enable = lib.mkEnableOption (lib.mdDoc "containerd container runtime");

     

       23
       23
        
       

     

       24
       24
        
           configFile = lib.mkOption {

     

       25
       25
        
             default = null;

+1 -1

nixos/modules/virtualisation/cri-o.nix

···

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
        
         options.virtualisation.cri-o = {

     

       23
       23
       -
           enable = mkEnableOption "Container Runtime Interface for OCI (CRI-O)";

     

       23
       23
       +
           enable = mkEnableOption (lib.mdDoc "Container Runtime Interface for OCI (CRI-O)");

     

       24
       24
        
       

     

       25
       25
        
           storageDriver = mkOption {

     

       26
       26
        
             type = types.enum [ "btrfs" "overlay" "vfs" ];

+1 -1

nixos/modules/virtualisation/ecs-agent.nix

···

       6
       6
        
         cfg = config.services.ecs-agent;

     

       7
       7
        
       in {

     

       8
       8
        
         options.services.ecs-agent = {

     

       9
       9
       -
           enable = mkEnableOption "Amazon ECS agent";

     

       9
       9
       +
           enable = mkEnableOption (lib.mdDoc "Amazon ECS agent");

     

       10
       10
        
       

     

       11
       11
        
           package = mkOption {

     

       12
       12
        
             type = types.path;

+1 -1

nixos/modules/virtualisation/hyperv-guest.nix

···

       8
       8
        
       in {

     

       9
       9
        
         options = {

     

       10
       10
        
           virtualisation.hypervGuest = {

     

       11
       11
       -
             enable = mkEnableOption "Hyper-V Guest Support";

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "Hyper-V Guest Support");

     

       12
       12
        
       

     

       13
       13
        
             videoMode = mkOption {

     

       14
       14
        
               type = types.str;

+3 -3

nixos/modules/virtualisation/nixos-containers.nix

···

       550
       550
        
                   ephemeral = mkOption {

     

       551
       551
        
                     type = types.bool;

     

       552
       552
        
                     default = false;

     

       553
       553
       -
                     description = ''

     

       553
       553
       +
                     description = lib.mdDoc ''

     

       554
       554
        
                       Runs container in ephemeral mode with the empty root filesystem at boot.

     

       555
       555
        
                       This way container will be bootstrapped from scratch on each boot

     

       556
       556
        
                       and will be cleaned up on shutdown leaving no traces behind.

     
···

       558
       558
        
       

     

       559
       559
        
                       Note that this option might require to do some adjustments to the container configuration,

     

       560
       560
        
                       e.g. you might want to set

     

       561
       561
       -
                       <varname>systemd.network.networks.$interface.dhcpV4Config.ClientIdentifier</varname> to "mac"

     

       562
       562
       -
                       if you use <varname>macvlans</varname> option.

     

       561
       561
       +
                       {var}`systemd.network.networks.$interface.dhcpV4Config.ClientIdentifier` to "mac"

     

       562
       562
       +
                       if you use {var}`macvlans` option.

     

       563
       563
        
                       This way dhcp client identifier will be stable between the container restarts.

     

       564
       564
        
       

     

       565
       565
        
                       Note that the container journal will not be linked to the host if this option is enabled.

+1 -1

nixos/modules/virtualisation/vmware-guest.nix

···

       13
       13
        
         ];

     

       14
       14
        
       

     

       15
       15
        
         options.virtualisation.vmware.guest = {

     

       16
       16
       -
           enable = mkEnableOption "VMWare Guest Support";

     

       16
       16
       +
           enable = mkEnableOption (lib.mdDoc "VMWare Guest Support");

     

       17
       17
        
           headless = mkOption {

     

       18
       18
        
             type = types.bool;

     

       19
       19
        
             default = false;

+1 -1

nixos/modules/virtualisation/waydroid.nix

···

       22
       22
        
       {

     

       23
       23
        
       

     

       24
       24
        
         options.virtualisation.waydroid = {

     

       25
       25
       -
           enable = mkEnableOption "Waydroid";

     

       25
       25
       +
           enable = mkEnableOption (lib.mdDoc "Waydroid");

     

       26
       26
        
         };

     

       27
       27
        
       

     

       28
       28
        
         config = mkIf cfg.enable {

+1 -1

nixos/modules/virtualisation/xe-guest-utilities.nix

···

       5
       5
        
       in {

     

       6
       6
        
         options = {

     

       7
       7
        
           services.xe-guest-utilities = {

     

       8
       8
       -
             enable = mkEnableOption "the Xen guest utilities daemon";

     

       8
       8
       +
             enable = mkEnableOption (lib.mdDoc "the Xen guest utilities daemon");

     

       9
       9
        
           };

     

       10
       10
        
         };

     

       11
       11
        
         config = mkIf cfg.enable {

+1 -1

nixos/modules/virtualisation/xen-dom0.nix

···

       139
       139
        
                 };

     

       140
       140
        
             };

     

       141
       141
        
       

     

       142
       142
       -
           virtualisation.xen.trace = mkEnableOption "Xen tracing";

     

       142
       142
       +
           virtualisation.xen.trace = mkEnableOption (lib.mdDoc "Xen tracing");

     

       143
       143
        
       

     

       144
       144
        
         };

     

       145
       145

+5 -5

nixos/tests/common/acme/server/default.nix

···

       81
       81
        
             type = types.str;

     

       82
       82
        
             readOnly = true;

     

       83
       83
        
             default = domain;

     

       84
       84
       -
             description = ''

     

       85
       85
       -
               A domain name to use with the <literal>nodes</literal> attribute to

     

       84
       84
       +
             description = lib.mdDoc ''

     

       85
       85
       +
               A domain name to use with the `nodes` attribute to

     

       86
       86
        
               identify the CA server.

     

       87
       87
        
             '';

     

       88
       88
        
           };

     
···

       90
       90
        
             type = types.path;

     

       91
       91
        
             readOnly = true;

     

       92
       92
        
             default = testCerts.ca.cert;

     

       93
       93
       -
             description = ''

     

       94
       94
       -
               A certificate file to use with the <literal>nodes</literal> attribute to

     

       93
       93
       +
             description = lib.mdDoc ''

     

       94
       94
       +
               A certificate file to use with the `nodes` attribute to

     

       95
       95
        
               inject the test CA certificate used in the ACME server into

     

       96
       96
       -
               <option>security.pki.certificateFiles</option>.

     

       96
       96
       +
               {option}`security.pki.certificateFiles`.

     

       97
       97
        
             '';

     

       98
       98
        
           };

     

       99
       99
        
         };

+3 -3

nixos/tests/common/auto.nix

···

       19
       19
        
       

     

       20
       20
        
             enable = mkOption {

     

       21
       21
        
               default = false;

     

       22
       22
       -
               description = ''

     

       22
       22
       +
               description = lib.mdDoc ''

     

       23
       23
        
                 Whether to enable the fake "auto" display manager, which

     

       24
       24
        
                 automatically logs in the user specified in the

     

       25
       25
       -
                 <option>user</option> option.  This is mostly useful for

     

       25
       25
       +
                 {option}`user` option.  This is mostly useful for

     

       26
       26
        
                 automated tests.

     

       27
       27
        
               '';

     

       28
       28
        
             };

     

       29
       29
        
       

     

       30
       30
        
             user = mkOption {

     

       31
       31
        
               default = "root";

     

       32
       32
       -
               description = "The user account to login automatically.";

     

       32
       32
       +
               description = lib.mdDoc "The user account to login automatically.";

     

       33
       33
        
             };

     

       34
       34
        
       

     

       35
       35
        
           };