···

       
7
       
7
       
 
       
in

     

       
8
       
8
       
 
       
{

     

       
9
       
9
       
 
       
  options.networking.iproute2 = {

     

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

     

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

     

       
11
       
11
       
 
       
    rttablesExtraConfig = mkOption {

     

       
12
       
12
       
 
       
      type = types.lines;

     

       
13
       
13
       
 
       
      default = "";

     

···

       
15
       
15
       
 
       
in

     

       
16
       
16
       
 
       
{

     

       
17
       
17
       
 
       
  options.networking.stevenblack = {

     

       
18
       
18
       
-
       
    enable = mkEnableOption (mdDoc "Enable the stevenblack hosts file blocklist");

     

       
18
       
18
       
+
       
    enable = mkEnableOption (mdDoc "the stevenblack hosts file blocklist");

     

       
19
       
19
       
 
       


     

       
20
       
20
       
 
       
    block = mkOption {

     

       
21
       
21
       
 
       
      type = types.listOf (types.enum [ "fakenews" "gambling" "porn" "social" ]);

     

···

       
8
       
8
       
 
       
{

     

       
9
       
9
       
 
       
  options.programs.corectrl = {

     

       
10
       
10
       
 
       
    enable = mkEnableOption (lib.mdDoc ''

     

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

     

       
11
       
11
       
+
       
      CoreCtrl, 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
       
 
       
    '');

     

       
14
       
14
       
 
       


     

       
15
       
15
       
 
       
    gpuOverclock = {

     

       
16
       
16
       
 
       
      enable = mkEnableOption (lib.mdDoc ''

     

       
17
       
17
       
-
       
        true

     

       
17
       
17
       
+
       
        GPU overclocking

     

       
18
       
18
       
 
       
      '');

     

       
19
       
19
       
 
       
      ppfeaturemask = mkOption {

     

       
20
       
20
       
 
       
        type = types.str;

     

···

       
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.

     

       
14
       
14
       
+
       
      logged on the computer locally

     

       
15
       
15
       
 
       
    '');

     

       
16
       
16
       
 
       


     

       
17
       
17
       
 
       
    group = mkOption {

     

···

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

     

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

     

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

     

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

     

       
14
       
14
       
+
       
      You may want to install the uhk-agent package

     

       
15
       
15
       
 
       
    '');

     

       
16
       
16
       
 
       


     

       
17
       
17
       
 
       
  };

     

···

       
11
       
11
       
 
       
      udev rules for keyboards from ZSA like the ErgoDox EZ, Planck EZ and Moonlander Mark I.

     

       
12
       
12
       
 
       
      You need it when you want to flash a new configuration on the keyboard

     

       
13
       
13
       
 
       
      or use their live training in the browser.

     

       
14
       
14
       
-
       
      You may want to install the wally-cli package.

     

       
14
       
14
       
+
       
      You may want to install the wally-cli package

     

       
15
       
15
       
 
       
    '');

     

       
16
       
16
       
 
       
  };

     

       
17
       
17
       
 
       


     

···

       
50
       
50
       
 
       
  options = {

     

       
51
       
51
       
 
       
    hardware.openrazer = {

     

       
52
       
52
       
 
       
      enable = mkEnableOption (lib.mdDoc ''

     

       
53
       
53
       
-
       
        OpenRazer drivers and userspace daemon.

     

       
53
       
53
       
+
       
        OpenRazer drivers and userspace daemon

     

       
54
       
54
       
 
       
      '');

     

       
55
       
55
       
 
       


     

       
56
       
56
       
 
       
      verboseLogging = mkOption {

     

···

       
9
       
9
       
 
       
  {

     

       
10
       
10
       
 
       
    options.hardware.tuxedo-keyboard = {

     

       
11
       
11
       
 
       
      enable = mkEnableOption (lib.mdDoc ''

     

       
12
       
12
       
-
       
          Enables the tuxedo-keyboard driver.

     

       
12
       
12
       
+
       
          the tuxedo-keyboard driver.

     

       
13
       
13
       
 
       


     

       
14
       
14
       
 
       
          To configure the driver, pass the options to the {option}`boot.kernelParams` configuration.

     

       
15
       
15
       
 
       
          There are several parameters you can change. It's best to check at the source code description which options are supported.

     

···

       
24
       
24
       
 
       
  options = {

     

       
25
       
25
       
 
       
    hardware.nvidia = {

     

       
26
       
26
       
 
       
      datacenter.enable = lib.mkEnableOption (lib.mdDoc ''

     

       
27
       
27
       
-
       
        Data Center drivers for NVIDIA cards on a NVLink topology.

     

       
27
       
27
       
+
       
        Data Center drivers for NVIDIA cards on a NVLink topology

     

       
28
       
28
       
 
       
      '');

     

       
29
       
29
       
 
       
      datacenter.settings = lib.mkOption {

     

       
30
       
30
       
 
       
        type = settingsFormat.type;

     
···

       
79
       
79
       
 
       


     

       
80
       
80
       
 
       
      powerManagement.enable = lib.mkEnableOption (lib.mdDoc ''

     

       
81
       
81
       
 
       
        experimental power management through systemd. For more information, see

     

       
82
       
82
       
-
       
        the NVIDIA docs, on Chapter 21. Configuring Power Management Support.

     

       
82
       
82
       
+
       
        the NVIDIA docs, on Chapter 21. Configuring Power Management Support

     

       
83
       
83
       
 
       
      '');

     

       
84
       
84
       
 
       


     

       
85
       
85
       
 
       
      powerManagement.finegrained = lib.mkEnableOption (lib.mdDoc ''

     

       
86
       
86
       
 
       
        experimental power management of PRIME offload. For more information, see

     

       
87
       
87
       
-
       
        the NVIDIA docs, on Chapter 22. PCI-Express Runtime D3 (RTD3) Power Management.

     

       
87
       
87
       
+
       
        the NVIDIA docs, on Chapter 22. PCI-Express Runtime D3 (RTD3) Power Management

     

       
88
       
88
       
 
       
      '');

     

       
89
       
89
       
 
       


     

       
90
       
90
       
 
       
      dynamicBoost.enable = lib.mkEnableOption (lib.mdDoc ''

     

       
91
       
91
       
 
       
        dynamic Boost balances power between the CPU and the GPU for improved

     

       
92
       
92
       
 
       
        performance on supported laptops using the nvidia-powerd daemon. For more

     

       
93
       
93
       
-
       
        information, see the NVIDIA docs, on Chapter 23. Dynamic Boost on Linux.

     

       
93
       
93
       
+
       
        information, see the NVIDIA docs, on Chapter 23. Dynamic Boost on Linux

     

       
94
       
94
       
 
       
      '');

     

       
95
       
95
       
 
       


     

       
96
       
96
       
 
       
      modesetting.enable = lib.mkEnableOption (lib.mdDoc ''

     
···

       
99
       
99
       
 
       
        Enabling this fixes screen tearing when using Optimus via PRIME (see

     

       
100
       
100
       
 
       
        {option}`hardware.nvidia.prime.sync.enable`. This is not enabled

     

       
101
       
101
       
 
       
        by default because it is not officially supported by NVIDIA and would not

     

       
102
       
102
       
-
       
        work with SLI.

     

       
102
       
102
       
+
       
        work with SLI

     

       
103
       
103
       
 
       
      '');

     

       
104
       
104
       
 
       


     

       
105
       
105
       
 
       
      prime.nvidiaBusId = lib.mkOption {

     
···

       
153
       
153
       
 
       


     

       
154
       
154
       
 
       
        Note that this configuration will only be successful when a display manager

     

       
155
       
155
       
 
       
        for which the {option}`services.xserver.displayManager.setupCommands`

     

       
156
       
156
       
-
       
        option is supported is used.

     

       
156
       
156
       
+
       
        option is supported is used

     

       
157
       
157
       
 
       
      '');

     

       
158
       
158
       
 
       


     

       
159
       
159
       
 
       
      prime.allowExternalGpu = lib.mkEnableOption (lib.mdDoc ''

     

       
160
       
160
       
-
       
        configuring X to allow external NVIDIA GPUs when using Prime [Reverse] sync optimus.

     

       
160
       
160
       
+
       
        configuring X to allow external NVIDIA GPUs when using Prime [Reverse] sync optimus

     

       
161
       
161
       
 
       
      '');

     

       
162
       
162
       
 
       


     

       
163
       
163
       
 
       
      prime.offload.enable = lib.mkEnableOption (lib.mdDoc ''

     
···

       
166
       
166
       
 
       
        If this is enabled, then the bus IDs of the NVIDIA and Intel/AMD GPUs have to

     

       
167
       
167
       
 
       
        be specified ({option}`hardware.nvidia.prime.nvidiaBusId` and

     

       
168
       
168
       
 
       
        {option}`hardware.nvidia.prime.intelBusId` or

     

       
169
       
169
       
-
       
        {option}`hardware.nvidia.prime.amdgpuBusId`).

     

       
169
       
169
       
+
       
        {option}`hardware.nvidia.prime.amdgpuBusId`)

     

       
170
       
170
       
 
       
      '');

     

       
171
       
171
       
 
       


     

       
172
       
172
       
 
       
      prime.offload.enableOffloadCmd = lib.mkEnableOption (lib.mdDoc ''

     
···

       
174
       
174
       
 
       
        for offloading programs to an nvidia device. To work, should have also enabled

     

       
175
       
175
       
 
       
        {option}`hardware.nvidia.prime.offload.enable` or {option}`hardware.nvidia.prime.reverseSync.enable`.

     

       
176
       
176
       
 
       


     

       
177
       
177
       
-
       
        Example usage `nvidia-offload sauerbraten_client`.

     

       
177
       
177
       
+
       
        Example usage `nvidia-offload sauerbraten_client`

     

       
178
       
178
       
 
       
      '');

     

       
179
       
179
       
 
       


     

       
180
       
180
       
 
       
      prime.reverseSync.enable = lib.mkEnableOption (lib.mdDoc ''

     
···

       
202
       
202
       
 
       


     

       
203
       
203
       
 
       
        Note that this configuration will only be successful when a display manager

     

       
204
       
204
       
 
       
        for which the {option}`services.xserver.displayManager.setupCommands`

     

       
205
       
205
       
-
       
        option is supported is used.

     

       
205
       
205
       
+
       
        option is supported is used

     

       
206
       
206
       
 
       
      '');

     

       
207
       
207
       
 
       


     

       
208
       
208
       
 
       
      nvidiaSettings =

     

       
209
       
209
       
 
       
        (lib.mkEnableOption (lib.mdDoc ''

     

       
210
       
210
       
-
       
          nvidia-settings, NVIDIA's GUI configuration tool.

     

       
210
       
210
       
+
       
          nvidia-settings, NVIDIA's GUI configuration tool

     

       
211
       
211
       
 
       
        ''))

     

       
212
       
212
       
 
       
        // {default = true;};

     

       
213
       
213
       
 
       


     

       
214
       
214
       
 
       
      nvidiaPersistenced = lib.mkEnableOption (lib.mdDoc ''

     

       
215
       
215
       
 
       
        nvidia-persistenced a update for NVIDIA GPU headless mode, i.e.

     

       
216
       
216
       
-
       
        It ensures all GPUs stay awake even during headless mode.

     

       
216
       
216
       
+
       
        It ensures all GPUs stay awake even during headless mode

     

       
217
       
217
       
 
       
      '');

     

       
218
       
218
       
 
       


     

       
219
       
219
       
 
       
      forceFullCompositionPipeline = lib.mkEnableOption (lib.mdDoc ''

     

       
220
       
220
       
 
       
        forcefully the full composition pipeline.

     

       
221
       
221
       
 
       
        This sometimes fixes screen tearing issues.

     

       
222
       
222
       
 
       
        This has been reported to reduce the performance of some OpenGL applications and may produce issues in WebGL.

     

       
223
       
223
       
-
       
        It also drastically increases the time the driver needs to clock down after load.

     

       
223
       
223
       
+
       
        It also drastically increases the time the driver needs to clock down after load

     

       
224
       
224
       
 
       
      '');

     

       
225
       
225
       
 
       


     

       
226
       
226
       
 
       
      package = lib.mkOption {

     

···

       
12
       
12
       
 
       


     

       
13
       
13
       
 
       
{

     

       
14
       
14
       
 
       


     

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

     

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

     

       
16
       
16
       
 
       


     

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

     

       
18
       
18
       
 
       
    default = false;

     

···

       
5
       
5
       
 
       


     

       
6
       
6
       
 
       
  inherit (config.nixops) enableDeprecatedAutoLuks;

     

       
7
       
7
       
 
       
in {

     

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

     

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

     

       
9
       
9
       
 
       


     

       
10
       
10
       
 
       
  config = {

     

       
11
       
11
       
 
       
    assertions = [

     

···

       
8
       
8
       
 
       
  options = {

     

       
9
       
9
       
 
       
    programs.calls = {

     

       
10
       
10
       
 
       
      enable = mkEnableOption (lib.mdDoc ''

     

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

     

       
11
       
11
       
+
       
        GNOME calls: a phone dialer and call handler

     

       
12
       
12
       
 
       
      '');

     

       
13
       
13
       
 
       
    };

     

       
14
       
14
       
 
       
  };

     

···

       
8
       
8
       
 
       
{

     

       
9
       
9
       
 
       
  options = {

     

       
10
       
10
       
 
       
    programs.cnping = {

     

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

     

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

     

       
12
       
12
       
 
       
    };

     

       
13
       
13
       
 
       
  };

     

       
14
       
14
       
 
       


     

···

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

     

       
12
       
12
       
 
       
      direnv integration. Takes care of both installation and

     

       
13
       
13
       
 
       
      setting up the sourcing of the shell. Additionally enables nix-direnv

     

       
14
       
14
       
-
       
      integration. Note that you need to logout and login for this change to apply.

     

       
14
       
14
       
+
       
      integration. Note that you need to logout and login for this change to apply

     

       
15
       
15
       
 
       
    '');

     

       
16
       
16
       
 
       


     

       
17
       
17
       
 
       
    package = lib.mkPackageOptionMD pkgs "direnv" {};

     

···

       
8
       
8
       
 
       
  options = {

     

       
9
       
9
       
 
       
    programs.feedbackd = {

     

       
10
       
10
       
 
       
      enable = mkEnableOption (lib.mdDoc ''

     

       
11
       
11
       
-
       
        Whether to enable the feedbackd D-BUS service and udev rules.

     

       
11
       
11
       
+
       
        the feedbackd D-BUS service and udev rules.

     

       
12
       
12
       
 
       


     

       
13
       
13
       
-
       
        Your user needs to be in the `feedbackd` group to trigger effects.

     

       
13
       
13
       
+
       
        Your user needs to be in the `feedbackd` group to trigger effects

     

       
14
       
14
       
 
       
      '');

     

       
15
       
15
       
 
       
      package = mkOption {

     

       
16
       
16
       
 
       
        description = lib.mdDoc ''

     

···

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

     

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

     

       
11
       
11
       
 
       
      `gnomeExtensions.gsconnect` as an alternative

     

       
12
       
12
       
-
       
      implementation if you use Gnome.

     

       
12
       
12
       
+
       
      implementation if you use Gnome

     

       
13
       
13
       
 
       
    '');

     

       
14
       
14
       
 
       
    package = mkOption {

     

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

     

···

       
6
       
6
       
 
       
  meta.maintainers = with lib.maintainers; [ rewine ];

     

       
7
       
7
       
 
       


     

       
8
       
8
       
 
       
  options.programs.wayfire = {

     

       
9
       
9
       
-
       
    enable = lib.mkEnableOption (lib.mdDoc "Wayfire, a wayland compositor based on wlroots.");

     

       
9
       
9
       
+
       
    enable = lib.mkEnableOption (lib.mdDoc "Wayfire, a wayland compositor based on wlroots");

     

       
10
       
10
       
 
       


     

       
11
       
11
       
 
       
    package = lib.mkPackageOptionMD pkgs "wayfire" { };

     

       
12
       
12
       
 
       


     

···

       
359
       
359
       
 
       
      };

     

       
360
       
360
       
 
       


     

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

     

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

     

       
362
       
362
       
+
       
        destroying 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.

     

       
365
       
365
       
+
       
        command fails

     

       
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.

     

       
369
       
369
       
+
       
        filesystem unmounted

     

       
370
       
370
       
 
       
      '');

     

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

     

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

     
···

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

     

       
378
       
378
       
 
       
        {manpage}`znapzend(1)`

     

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

     

       
380
       
380
       
-
       
        for more info.

     

       
380
       
380
       
+
       
        for more info

     

       
381
       
381
       
 
       
      '');

     

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

     

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

     
···

       
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.

     

       
389
       
389
       
+
       
        non-raw snapshots and vice versa

     

       
390
       
390
       
 
       
      '');

     

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

     

       
392
       
392
       
-
       
        Enable the skipIntermediates feature to send a single increment

     

       
392
       
392
       
+
       
        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.

     

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

     

       
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`: instead, go the slower

     

       
403
       
403
       
 
       
        way to first list all impacted dataset names, and then query their

     

       
404
       
404
       
-
       
        configs one by one.

     

       
404
       
404
       
+
       
        configs one by one

     

       
405
       
405
       
 
       
      '');

     

       
406
       
406
       
 
       
      features.zfsGetType = mkEnableOption (lib.mdDoc ''

     

       
407
       
407
       
-
       
        use zfsGetType if your {command}`zfs get` supports a

     

       
407
       
407
       
+
       
        using 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.

     
···

       
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.

     

       
415
       
415
       
+
       
        of those), so you would benefit from requesting this feature

     

       
416
       
416
       
 
       
      '');

     

       
417
       
417
       
 
       
    };

     

       
418
       
418
       
 
       
  };

     

···

       
122
       
122
       
 
       
  options.services.cassandra = {

     

       
123
       
123
       
 
       


     

       
124
       
124
       
 
       
    enable = mkEnableOption (lib.mdDoc ''

     

       
125
       
125
       
-
       
      Apache Cassandra – Scalable and highly available database.

     

       
125
       
125
       
+
       
      Apache Cassandra – Scalable and highly available database

     

       
126
       
126
       
 
       
    '');

     

       
127
       
127
       
 
       


     

       
128
       
128
       
 
       
    clusterName = mkOption {

     

···

       
11
       
11
       
 
       


     

       
12
       
12
       
 
       
  options = {

     

       
13
       
13
       
 
       
    services.ferretdb = {

     

       
14
       
14
       
-
       
      enable = mkEnableOption "FerretDB, an Open Source MongoDB alternative.";

     

       
14
       
14
       
+
       
      enable = mkEnableOption "FerretDB, an Open Source MongoDB alternative";

     

       
15
       
15
       
 
       


     

       
16
       
16
       
 
       
      package = mkOption {

     

       
17
       
17
       
 
       
        type = types.package;

     

···

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

     

       
78
       
78
       
+
       
              e.g. (https://redis.io/topics/latency)

     

       
79
       
79
       
 
       
            '');

     

       
80
       
80
       
 
       


     

       
81
       
81
       
 
       
            user = mkOption {

     

···

       
8
       
8
       
 
       


     

       
9
       
9
       
 
       
  options = {

     

       
10
       
10
       
 
       
    services.surrealdb = {

     

       
11
       
11
       
-
       
      enable = mkEnableOption (lib.mdDoc "A scalable, distributed, collaborative, document-graph database, for the realtime web ");

     

       
11
       
11
       
+
       
      enable = mkEnableOption (lib.mdDoc "SurrealDB, a scalable, distributed, collaborative, document-graph database, for the realtime web");

     

       
12
       
12
       
 
       


     

       
13
       
13
       
 
       
      package = mkOption {

     

       
14
       
14
       
 
       
        default = pkgs.surrealdb;

     

···

       
14
       
14
       
 
       


     

       
15
       
15
       
 
       
    services.deepin.app-services = {

     

       
16
       
16
       
 
       


     

       
17
       
17
       
-
       
      enable = mkEnableOption (lib.mdDoc "Service collection of DDE applications, including dconfig-center");

     

       
17
       
17
       
+
       
      enable = mkEnableOption (lib.mdDoc "service collection of DDE applications, including dconfig-center");

     

       
18
       
18
       
 
       


     

       
19
       
19
       
 
       
    };

     

       
20
       
20
       
 
       


     

···

       
15
       
15
       
 
       
    services.deepin.dde-api = {

     

       
16
       
16
       
 
       


     

       
17
       
17
       
 
       
      enable = mkEnableOption (lib.mdDoc ''

     

       
18
       
18
       
-
       
        Provides some dbus interfaces that is used for screen zone detecting,

     

       
19
       
19
       
-
       
        thumbnail generating, and sound playing in Deepin Desktop Environment.

     

       
18
       
18
       
+
       
        some dbus interfaces that is used for screen zone detecting,

     

       
19
       
19
       
+
       
        thumbnail generating, and sound playing in Deepin Desktop Environment

     

       
20
       
20
       
 
       
      '');

     

       
21
       
21
       
 
       


     

       
22
       
22
       
 
       
    };

     

···

       
14
       
14
       
 
       


     

       
15
       
15
       
 
       
    services.deepin.dde-daemon = {

     

       
16
       
16
       
 
       


     

       
17
       
17
       
-
       
      enable = mkEnableOption (lib.mdDoc "Daemon for handling the deepin session settings");

     

       
17
       
17
       
+
       
      enable = mkEnableOption (lib.mdDoc "daemon for handling the deepin session settings");

     

       
18
       
18
       
 
       


     

       
19
       
19
       
 
       
    };

     

       
20
       
20
       
 
       


     

···

       
24
       
24
       
 
       


     

       
25
       
25
       
 
       
  options = {

     

       
26
       
26
       
 
       
    services.gnome.gnome-browser-connector.enable = mkEnableOption (mdDoc ''

     

       
27
       
27
       
-
       
      Native host connector for the GNOME Shell browser extension, a DBus service

     

       
28
       
28
       
-
       
      allowing to install GNOME Shell extensions from a web browser.

     

       
27
       
27
       
+
       
      native host connector for the GNOME Shell browser extension, a DBus service

     

       
28
       
28
       
+
       
      allowing to install GNOME Shell extensions from a web browser

     

       
29
       
29
       
 
       
    '');

     

       
30
       
30
       
 
       
  };

     

       
31
       
31
       
 
       


     

···

       
7
       
7
       
 
       
{

     

       
8
       
8
       
 
       
  options = {

     

       
9
       
9
       
 
       
    services.supergfxd = {

     

       
10
       
10
       
-
       
      enable = lib.mkEnableOption (lib.mdDoc "Enable the supergfxd service");

     

       
10
       
10
       
+
       
      enable = lib.mkEnableOption (lib.mdDoc "the supergfxd service");

     

       
11
       
11
       
 
       


     

       
12
       
12
       
 
       
      settings = lib.mkOption {

     

       
13
       
13
       
 
       
        type = lib.types.nullOr json.type;

     

···

       
9
       
9
       
 
       
{

     

       
10
       
10
       
 
       
  options = {

     

       
11
       
11
       
 
       
    hardware.tuxedo-rs = {

     

       
12
       
12
       
-
       
      enable = mkEnableOption (lib.mdDoc "Rust utilities for interacting with hardware from TUXEDO Computers.");

     

       
12
       
12
       
+
       
      enable = mkEnableOption (lib.mdDoc "Rust utilities for interacting with hardware from TUXEDO Computers");

     

       
13
       
13
       
 
       


     

       
14
       
14
       
-
       
      tailor-gui.enable = mkEnableOption (lib.mdDoc "Alternative to TUXEDO Control Center, written in Rust.");

     

       
14
       
14
       
+
       
      tailor-gui.enable = mkEnableOption (lib.mdDoc "tailor-gui, an alternative to TUXEDO Control Center, written in Rust");

     

       
15
       
15
       
 
       
    };

     

       
16
       
16
       
 
       
  };

     

       
17
       
17
       
 
       


     

···

       
302
       
302
       
 
       


     

       
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 (lib.mdDoc "enable ssl_dh and generation of primes for the key exchange") // { default = true; };

     

       
305
       
305
       
+
       
    enableDHE = mkEnableOption (lib.mdDoc "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;

     

···

       
260
       
260
       
 
       
      };

     

       
261
       
261
       
 
       


     

       
262
       
262
       
 
       
      serve = {

     

       
263
       
263
       
-
       
        enable = mkEnableOption (lib.mdDoc "Automatic nginx and uwsgi setup for mailman-web");

     

       
263
       
263
       
+
       
        enable = mkEnableOption (lib.mdDoc "automatic nginx and uwsgi setup for mailman-web");

     

       
264
       
264
       
 
       


     

       
265
       
265
       
 
       
        virtualRoot = mkOption {

     

       
266
       
266
       
 
       
          default = "/";

     

···

       
96
       
96
       
 
       
      type = types.submodule {

     

       
97
       
97
       
 
       
        options = {

     

       
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.

     

       
99
       
99
       
+
       
            ignoring the accessToken. 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
       
 
       
          '');

     

       
102
       
102
       
 
       


     

       
103
       
103
       
 
       
          username = mkOption {

     

···

       
111
       
111
       
 
       
          (submodule {

     

       
112
       
112
       
 
       
            options = {

     

       
113
       
113
       
 
       
              enable = mkEnableOption (lib.mdDoc ''

     

       
114
       
114
       
-
       
                building of firmware for manual flashing.

     

       
114
       
114
       
+
       
                building of firmware for manual flashing

     

       
115
       
115
       
 
       
              '');

     

       
116
       
116
       
 
       
              enableKlipperFlash = mkEnableOption (lib.mdDoc ''

     

       
117
       
117
       
 
       
                flashings scripts for firmware. This will add `klipper-flash-$mcu` scripts to your environment which can be called to flash the firmware.

     

       
118
       
118
       
-
       
                Please check the configs at [klipper](https://github.com/Klipper3d/klipper/tree/master/config) whether your board supports flashing via `make flash`.

     

       
118
       
118
       
+
       
                Please check the configs at [klipper](https://github.com/Klipper3d/klipper/tree/master/config) whether your board supports flashing via `make flash`

     

       
119
       
119
       
 
       
              '');

     

       
120
       
120
       
 
       
              serial = mkOption {

     

       
121
       
121
       
 
       
                type = types.nullOr path;

     

···

       
40
       
40
       
 
       


     

       
41
       
41
       
 
       
  options.services.packagekit = {

     

       
42
       
42
       
 
       
    enable = mkEnableOption (lib.mdDoc ''

     

       
43
       
43
       
-
       
      PackageKit provides a cross-platform D-Bus abstraction layer for

     

       
43
       
43
       
+
       
      PackageKit, 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.

     

       
45
       
45
       
+
       
      software regardless of the package manager

     

       
46
       
46
       
 
       
    '');

     

       
47
       
47
       
 
       


     

       
48
       
48
       
 
       
    settings = mkOption {

     

···

       
12
       
12
       
 
       
in

     

       
13
       
13
       
 
       
{

     

       
14
       
14
       
 
       
  options.services.rshim = {

     

       
15
       
15
       
-
       
    enable = lib.mkEnableOption (lib.mdDoc "User-space rshim driver for the BlueField SoC");

     

       
15
       
15
       
+
       
    enable = lib.mkEnableOption (lib.mdDoc "user-space rshim driver for the BlueField SoC");

     

       
16
       
16
       
 
       


     

       
17
       
17
       
 
       
    package = lib.mkPackageOptionMD pkgs "rshim-user-space" { };

     

       
18
       
18
       
 
       


     

···

       
438
       
438
       
 
       
        };

     

       
439
       
439
       
 
       


     

       
440
       
440
       
 
       
        options."lists.sr.ht" = commonServiceSettings "lists" // {

     

       
441
       
441
       
-
       
          allow-new-lists = mkEnableOption (lib.mdDoc "Allow creation of new lists");

     

       
441
       
441
       
+
       
          allow-new-lists = mkEnableOption (lib.mdDoc "creation of new lists");

     

       
442
       
442
       
 
       
          notify-from = mkOption {

     

       
443
       
443
       
 
       
            description = lib.mdDoc "Outgoing email for notifications generated by users.";

     

       
444
       
444
       
 
       
            type = types.str;

     

···

       
9
       
9
       
 
       


     

       
10
       
10
       
 
       
  options = {

     

       
11
       
11
       
 
       
    services.tp-auto-kbbl = {

     

       
12
       
12
       
-
       
      enable = mkEnableOption (lib.mdDoc "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;

     

···

       
67
       
67
       
 
       
  options = {

     

       
68
       
68
       
 
       
    services.zoneminder = with lib; {

     

       
69
       
69
       
 
       
      enable = lib.mkEnableOption (lib.mdDoc ''

     

       
70
       
70
       
-
       
        ZoneMinder

     

       
70
       
70
       
+
       
        ZoneMinder.

     

       
71
       
71
       
 
       


     

       
72
       
72
       
 
       
        If you intend to run the database locally, you should set

     

       
73
       
73
       
 
       
        `config.services.zoneminder.database.createLocally` to true. Otherwise,

     

       
74
       
74
       
 
       
        when set to `false` (the default), you will have to create the database

     

       
75
       
75
       
 
       
        and database user as well as populate the database yourself.

     

       
76
       
76
       
 
       
        Additionally, you will need to run `zmupdate.pl` yourself when

     

       
77
       
77
       
-
       
        upgrading to a newer version.

     

       
77
       
77
       
+
       
        upgrading to a newer version

     

       
78
       
78
       
 
       
      '');

     

       
79
       
79
       
 
       


     

       
80
       
80
       
 
       
      webserver = mkOption {

     

···

       
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 (lib.mdDoc "Whether to run as root");

     

       
14
       
14
       
+
       
    runAsRoot = mkEnableOption (lib.mdDoc "running as root");

     

       
15
       
15
       
 
       


     

       
16
       
16
       
 
       
    autoRetirement = mkEnableOption (lib.mdDoc ''

     

       
17
       
17
       
-
       
      Whether to automatically retire the host upon OS shutdown.

     

       
17
       
17
       
+
       
      retiring the host upon OS shutdown

     

       
18
       
18
       
 
       
    '');

     

       
19
       
19
       
 
       


     

       
20
       
20
       
 
       
    apiKeyFile = mkOption {

     
···

       
59
       
59
       
 
       
        };

     

       
60
       
60
       
 
       


     

       
61
       
61
       
 
       
        options.diagnostic =

     

       
62
       
62
       
-
       
          mkEnableOption (lib.mdDoc "Collect memory usage for the agent itself");

     

       
62
       
62
       
+
       
          mkEnableOption (lib.mdDoc "collecting memory usage for the agent itself");

     

       
63
       
63
       
 
       
      };

     

       
64
       
64
       
 
       
    };

     

       
65
       
65
       
 
       
  };

     

···

       
11
       
11
       
 
       
    ({ options.warnings = options.warnings; options.assertions = options.assertions; })

     

       
12
       
12
       
 
       
  ];

     

       
13
       
13
       
 
       
  extraOpts = {

     

       
14
       
14
       
-
       
    verbose = mkEnableOption (lib.mdDoc "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);

     

···

       
177
       
177
       
 
       


     

       
178
       
178
       
 
       
        backup = {

     

       
179
       
179
       
 
       
          enable = mkEnableOption (lib.mdDoc ''

     

       
180
       
180
       
-
       
            Backup server role. When using OpenAFS built-in buserver, use in conjunction with the

     

       
180
       
180
       
+
       
            the backup server role. When using OpenAFS built-in buserver, use in conjunction with the

     

       
181
       
181
       
 
       
            `database` role to maintain the Backup

     

       
182
       
182
       
 
       
            Database. Normally only used in conjunction with tape storage

     

       
183
       
183
       
 
       
            or IBM's Tivoli Storage Manager.

     

       
184
       
184
       
 
       


     

       
185
       
185
       
 
       
            For a modern backup server, enable this role and see

     

       
186
       
186
       
-
       
            {option}`enableFabs`.

     

       
186
       
186
       
+
       
            {option}`enableFabs`

     

       
187
       
187
       
 
       
          '');

     

       
188
       
188
       
 
       


     

       
189
       
189
       
 
       
          enableFabs = mkEnableOption (lib.mdDoc ''

     

···

       
8
       
8
       
 
       
in {

     

       
9
       
9
       
 
       
  options = {

     

       
10
       
10
       
 
       
    services.create_ap = {

     

       
11
       
11
       
-
       
      enable = mkEnableOption (lib.mdDoc "setup wifi hotspots using create_ap");

     

       
11
       
11
       
+
       
      enable = mkEnableOption (lib.mdDoc "setting up wifi hotspots using create_ap");

     

       
12
       
12
       
 
       
      settings = mkOption {

     

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

     

       
14
       
14
       
 
       
        default = {};

     

···

       
14
       
14
       
 
       
  options = {

     

       
15
       
15
       
 
       
    services.dae = with lib;{

     

       
16
       
16
       
 
       
      enable = mkEnableOption

     

       
17
       
17
       
-
       
        (mdDoc "A Linux high-performance transparent proxy solution based on eBPF");

     

       
17
       
17
       
+
       
        (mdDoc "dae, a Linux high-performance transparent proxy solution based on eBPF");

     

       
18
       
18
       
 
       


     

       
19
       
19
       
 
       
      package = mkPackageOptionMD pkgs "dae" { };

     

       
20
       
20
       
 
       


     
···

       
46
       
46
       
 
       
      openFirewall = mkOption {

     

       
47
       
47
       
 
       
        type = with types; submodule {

     

       
48
       
48
       
 
       
          options = {

     

       
49
       
49
       
-
       
            enable = mkEnableOption "enable";

     

       
49
       
49
       
+
       
            enable = mkEnableOption (mdDoc "opening {option}`port` in the firewall");

     

       
50
       
50
       
 
       
            port = mkOption {

     

       
51
       
51
       
 
       
              type = types.port;

     

       
52
       
52
       
 
       
              description = ''

     
···

       
91
       
91
       
 
       
      };

     

       
92
       
92
       
 
       


     

       
93
       
93
       
 
       
      disableTxChecksumIpGeneric =

     

       
94
       
94
       
-
       
        mkEnableOption (mdDoc "See <https://github.com/daeuniverse/dae/issues/43>");

     

       
94
       
94
       
+
       
        mkEnableOption "" // { description = mdDoc "See <https://github.com/daeuniverse/dae/issues/43>"; };

     

       
95
       
95
       
 
       


     

       
96
       
96
       
 
       
    };

     

       
97
       
97
       
 
       
  };

     

···

       
54
       
54
       
 
       
      description = "TCP port for the WebSocket.";

     

       
55
       
55
       
 
       
    };

     

       
56
       
56
       
 
       


     

       
57
       
57
       
-
       
    openFirewall = lib.mkEnableOption "open up the service ports in the firewall";

     

       
57
       
57
       
+
       
    openFirewall = lib.mkEnableOption "opening up the service ports in the firewall";

     

       
58
       
58
       
 
       


     

       
59
       
59
       
-
       
    allowRebootSystem = lib.mkEnableOption "allow rebooting the system";

     

       
59
       
59
       
+
       
    allowRebootSystem = lib.mkEnableOption "rebooting the system";

     

       
60
       
60
       
 
       


     

       
61
       
61
       
-
       
    allowRestartService = lib.mkEnableOption "allow killing/restarting processes";

     

       
61
       
61
       
+
       
    allowRestartService = lib.mkEnableOption "killing/restarting processes";

     

       
62
       
62
       
 
       


     

       
63
       
63
       
-
       
    allowSetSystemTime = lib.mkEnableOption "allow setting the system time";

     

       
63
       
63
       
+
       
    allowSetSystemTime = lib.mkEnableOption "setting the system time";

     

       
64
       
64
       
 
       


     

       
65
       
65
       
 
       
    extraArgs = lib.mkOption {

     

       
66
       
66
       
 
       
      type = lib.types.listOf lib.types.str;

     

···

       
9
       
9
       
 
       
  configFile = settingsFormat.generate "config.yaml" cfg.config;

     

       
10
       
10
       
 
       
in {

     

       
11
       
11
       
 
       
  options.services.go-neb = {

     

       
12
       
12
       
-
       
    enable = mkEnableOption (lib.mdDoc "Extensible matrix bot written in Go");

     

       
12
       
12
       
+
       
    enable = mkEnableOption (lib.mdDoc "an extensible matrix bot written in Go");

     

       
13
       
13
       
 
       


     

       
14
       
14
       
 
       
    bindAddress = mkOption {

     

       
15
       
15
       
 
       
      type = types.str;

     

···

       
116
       
116
       
 
       
  options = {

     

       
117
       
117
       
 
       
    services.hostapd = {

     

       
118
       
118
       
 
       
      enable = mkEnableOption (mdDoc ''

     

       
119
       
119
       
-
       
        Whether to enable hostapd. hostapd is a user space daemon for access point and

     

       
119
       
119
       
+
       
        hostapd, a user space daemon for access point and

     

       
120
       
120
       
 
       
        authentication servers. It implements IEEE 802.11 access point management,

     

       
121
       
121
       
 
       
        IEEE 802.1X/WPA/WPA2/EAP Authenticators, RADIUS client, EAP server, and RADIUS

     

       
122
       
122
       
-
       
        authentication server.

     

       
122
       
122
       
+
       
        authentication server

     

       
123
       
123
       
 
       
      '');

     

       
124
       
124
       
 
       


     

       
125
       
125
       
 
       
      package = mkPackageOption pkgs "hostapd" {};

     

···

       
272
       
272
       
 
       
    };

     

       
273
       
273
       
 
       


     

       
274
       
274
       
 
       
    faxcron.enable.spoolInit = mkEnableOption (lib.mdDoc ''

     

       
275
       
275
       
-
       
      Purge old files from the spooling area with

     

       
275
       
275
       
+
       
      purging old files from the spooling area with

     

       
276
       
276
       
 
       
      {file}`faxcron`

     

       
277
       
277
       
-
       
      each time the spooling area is initialized.

     

       
277
       
277
       
+
       
      each time the spooling area is initialized

     

       
278
       
278
       
 
       
    '');

     

       
279
       
279
       
 
       
    faxcron.enable.frequency = mkOption {

     

       
280
       
280
       
 
       
      type = nullOr nonEmptyStr;

     

       
281
       
281
       
 
       
      default = null;

     

       
282
       
282
       
 
       
      example = "daily";

     

       
283
       
283
       
 
       
      description = lib.mdDoc ''

     

       
284
       
284
       
-
       
        Purge old files from the spooling area with

     

       
284
       
284
       
+
       
        purging old files from the spooling area with

     

       
285
       
285
       
 
       
        {file}`faxcron` with the given frequency

     

       
286
       
286
       
-
       
        (see systemd.time(7)).

     

       
286
       
286
       
+
       
        (see systemd.time(7))

     

       
287
       
287
       
 
       
      '';

     

       
288
       
288
       
 
       
    };

     

       
289
       
289
       
 
       
    faxcron.infoDays = mkOption {

     

···

       
265
       
265
       
 
       
        '';

     

       
266
       
266
       
 
       
      };

     

       
267
       
267
       
 
       


     

       
268
       
268
       
-
       
      logCLFTime = mkEnableOption (lib.mdDoc "Full CLF-formatted date and time to log");

     

       
268
       
268
       
+
       
      logCLFTime = mkEnableOption (lib.mdDoc "full CLF-formatted date and time to log");

     

       
269
       
269
       
 
       


     

       
270
       
270
       
 
       
      address = mkOption {

     

       
271
       
271
       
 
       
        type = with types; nullOr str;

     
···

       
456
       
456
       
 
       
        '';

     

       
457
       
457
       
 
       
      };

     

       
458
       
458
       
 
       


     

       
459
       
459
       
-
       
      trust.enable = mkEnableOption (lib.mdDoc "Explicit trust options");

     

       
459
       
459
       
+
       
      trust.enable = mkEnableOption (lib.mdDoc "explicit trust options");

     

       
460
       
460
       
 
       


     

       
461
       
461
       
 
       
      trust.family = mkOption {

     

       
462
       
462
       
 
       
        type = with types; nullOr str;

     
···

       
474
       
474
       
 
       
        '';

     

       
475
       
475
       
 
       
      };

     

       
476
       
476
       
 
       


     

       
477
       
477
       
-
       
      trust.hidden = mkEnableOption (lib.mdDoc "Router concealment");

     

       
477
       
477
       
+
       
      trust.hidden = mkEnableOption (lib.mdDoc "router concealment");

     

       
478
       
478
       
 
       


     

       
479
       
479
       
 
       
      websocket = mkEndpointOpt "websockets" "127.0.0.1" 7666;

     

       
480
       
480
       
 
       


     
···

       
552
       
552
       
 
       


     

       
553
       
553
       
 
       
      proto.http = (mkEndpointOpt "http" "127.0.0.1" 7070) // {

     

       
554
       
554
       
 
       


     

       
555
       
555
       
-
       
        auth = mkEnableOption (lib.mdDoc "Webconsole authentication");

     

       
555
       
555
       
+
       
        auth = mkEnableOption (lib.mdDoc "webconsole authentication");

     

       
556
       
556
       
 
       


     

       
557
       
557
       
 
       
        user = mkOption {

     

       
558
       
558
       
 
       
          type = types.str;

     

···

       
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.

     

       
10
       
10
       
+
       
      You probably do not want this

     

       
11
       
11
       
 
       
    '');

     

       
12
       
12
       
 
       
    discoverPortal = mkOption {

     

       
13
       
13
       
 
       
      type = nullOr str;

     

···

       
10
       
10
       
 
       
  };

     

       
11
       
11
       
 
       
  options = {

     

       
12
       
12
       
 
       
    services.nar-serve = {

     

       
13
       
13
       
-
       
      enable = mkEnableOption (lib.mdDoc "Serve NAR file contents via HTTP");

     

       
13
       
13
       
+
       
      enable = mkEnableOption (lib.mdDoc "serving NAR file contents via HTTP");

     

       
14
       
14
       
 
       


     

       
15
       
15
       
 
       
      port = mkOption {

     

       
16
       
16
       
 
       
        type = types.port;

     

···

       
103
       
103
       
 
       
      '';

     

       
104
       
104
       
 
       
    };

     

       
105
       
105
       
 
       


     

       
106
       
106
       
-
       
    networking.nftables.flushRuleset = mkEnableOption (lib.mdDoc "Flush the entire ruleset on each reload.");

     

       
106
       
106
       
+
       
    networking.nftables.flushRuleset = mkEnableOption (lib.mdDoc "flushing the entire ruleset on each reload");

     

       
107
       
107
       
 
       


     

       
108
       
108
       
 
       
    networking.nftables.extraDeletions = mkOption {

     

       
109
       
109
       
 
       
      type = types.lines;

     

···

       
8
       
8
       
 
       
{

     

       
9
       
9
       
 
       
  options = {

     

       
10
       
10
       
 
       
    services.snowflake-proxy = {

     

       
11
       
11
       
-
       
      enable = mkEnableOption (lib.mdDoc "System to defeat internet censorship");

     

       
11
       
11
       
+
       
      enable = mkEnableOption (lib.mdDoc "snowflake-proxy, a system to defeat internet censorship");

     

       
12
       
12
       
 
       


     

       
13
       
13
       
 
       
      broker = mkOption {

     

       
14
       
14
       
 
       
        description = lib.mdDoc "Broker URL (default \"https://snowflake-broker.torproject.net/\")";

     

···

       
116
       
116
       
 
       
      };

     

       
117
       
117
       
 
       


     

       
118
       
118
       
 
       
      persistentKeys = mkEnableOption (lib.mdDoc ''

     

       
119
       
119
       
-
       
        If enabled then keys will be generated once and Yggdrasil

     

       
119
       
119
       
+
       
        persistent keys. If enabled then keys will be generated once and Yggdrasil

     

       
120
       
120
       
 
       
        will retain the same IPv6 address when the service is

     

       
121
       
121
       
-
       
        restarted. Keys are stored at ${keysPath}.

     

       
121
       
121
       
+
       
        restarted. Keys are stored at ${keysPath}

     

       
122
       
122
       
 
       
      '');

     

       
123
       
123
       
 
       


     

       
124
       
124
       
 
       
      extraArgs = mkOption {

     

···

       
11
       
11
       
 
       
in

     

       
12
       
12
       
 
       
{

     

       
13
       
13
       
 
       
  options.services.earlyoom = {

     

       
14
       
14
       
-
       
    enable = mkEnableOption (lib.mdDoc "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;

     

···

       
13
       
13
       
 
       


     

       
14
       
14
       
 
       
      WARNING: enabling this option (while convenient) should *not* be done on a

     

       
15
       
15
       
 
       
      machine where you do not trust the other users as it allows any other

     

       
16
       
16
       
-
       
      local user to DoS your session by spamming notifications.

     

       
16
       
16
       
+
       
      local user to DoS your session by spamming notifications

     

       
17
       
17
       
 
       
    '');

     

       
18
       
18
       
 
       
  };

     

       
19
       
19
       
 
       


     

···

       
14
       
14
       
 
       
in {

     

       
15
       
15
       
 
       
  options = {

     

       
16
       
16
       
 
       
    services.flexget = {

     

       
17
       
17
       
-
       
      enable = mkEnableOption (lib.mdDoc "Run FlexGet Daemon");

     

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

     

       
18
       
18
       
 
       


     

       
19
       
19
       
 
       
      package = mkPackageOptionMD pkgs "flexget" {};

     

       
20
       
20
       
 
       


     

···

       
40
       
40
       
 
       
      };

     

       
41
       
41
       
 
       


     

       
42
       
42
       
 
       
      allowVideoAccess = lib.mkEnableOption (lib.mdDoc ''

     

       
43
       
43
       
-
       
        Enable access to video devices like cameras on the system.

     

       
43
       
43
       
+
       
        access to video devices like cameras on the system

     

       
44
       
44
       
 
       
      '');

     

       
45
       
45
       
 
       
    };

     

       
46
       
46
       
 
       
  };

     

···

       
69
       
69
       
 
       
in

     

       
70
       
70
       
 
       
{

     

       
71
       
71
       
 
       
  options.services.cloudlog = with types; {

     

       
72
       
72
       
-
       
    enable = mkEnableOption (mdDoc "Whether to enable Cloudlog");

     

       
72
       
72
       
+
       
    enable = mkEnableOption (mdDoc "Cloudlog");

     

       
73
       
73
       
 
       
    dataDir = mkOption {

     

       
74
       
74
       
 
       
      type = str;

     

       
75
       
75
       
 
       
      default = "/var/lib/cloudlog";

     

···

       
7
       
7
       
 
       


     

       
8
       
8
       
 
       
    enable = mkEnableOption (lib.mdDoc "hledger-web service");

     

       
9
       
9
       
 
       


     

       
10
       
10
       
-
       
    serveApi = mkEnableOption (lib.mdDoc "Serve only the JSON web API, without the web UI");

     

       
10
       
10
       
+
       
    serveApi = mkEnableOption (lib.mdDoc "serving only the JSON web API, without the web UI");

     

       
11
       
11
       
 
       


     

       
12
       
12
       
 
       
    host = mkOption {

     

       
13
       
13
       
 
       
      type = types.str;

     

···

       
12
       
12
       
 
       
  options = {

     

       
13
       
13
       
 
       
    services.isso = {

     

       
14
       
14
       
 
       
      enable = mkEnableOption (lib.mdDoc ''

     

       
15
       
15
       
-
       
        A commenting server similar to Disqus.

     

       
15
       
15
       
+
       
        isso, 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.

     

       
19
       
19
       
+
       
        below 20 requests per second

     

       
20
       
20
       
 
       
      '');

     

       
21
       
21
       
 
       


     

       
22
       
22
       
 
       
      settings = mkOption {

     

···

       
105
       
105
       
 
       
        type = bool;

     

       
106
       
106
       
 
       
        default = true;

     

       
107
       
107
       
 
       
        description = lib.mdDoc ''

     

       
108
       
108
       
-
       
          Whether to enable Jitsi Videobridge instance and configure it to connect to Prosody.

     

       
108
       
108
       
+
       
          Jitsi Videobridge instance and configure it to connect to Prosody.

     

       
109
       
109
       
 
       


     

       
110
       
110
       
-
       
          Additional configuration is possible with {option}`services.jitsi-videobridge`.

     

       
110
       
110
       
+
       
          Additional configuration is possible with {option}`services.jitsi-videobridge`

     

       
111
       
111
       
 
       
        '';

     

       
112
       
112
       
 
       
      };

     

       
113
       
113
       
 
       


     

···

       
8
       
8
       
 
       
  options = {

     

       
9
       
9
       
 
       
    services.meme-bingo-web = {

     

       
10
       
10
       
 
       
      enable = mkEnableOption (mdDoc ''

     

       
11
       
11
       
-
       
        A web app for the meme bingo, rendered entirely on the web server and made interactive with forms.

     

       
11
       
11
       
+
       
        a web app for the meme bingo, rendered entirely on the web server and made interactive with forms.

     

       
12
       
12
       
 
       


     

       
13
       
13
       
-
       
        Note: The application's author suppose to run meme-bingo-web behind a reverse proxy for SSL and HTTP/3.

     

       
13
       
13
       
+
       
        Note: The application's author suppose to run meme-bingo-web behind a reverse proxy for SSL and HTTP/3

     

       
14
       
14
       
 
       
      '');

     

       
15
       
15
       
 
       


     

       
16
       
16
       
 
       
      package = mkOption {

     

···

       
4
       
4
       
 
       
let cfg = config.services.phylactery;

     

       
5
       
5
       
 
       
in {

     

       
6
       
6
       
 
       
  options.services.phylactery = {

     

       
7
       
7
       
-
       
    enable = mkEnableOption (lib.mdDoc "Whether to enable Phylactery server");

     

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

     

       
8
       
8
       
 
       


     

       
9
       
9
       
 
       
    host = mkOption {

     

       
10
       
10
       
 
       
      type = types.str;

     

···

       
30
       
30
       
 
       
in {

     

       
31
       
31
       
 
       
  options.services.snipe-it = {

     

       
32
       
32
       
 
       


     

       
33
       
33
       
-
       
    enable = mkEnableOption (lib.mdDoc "A free open source IT asset/license management system");

     

       
33
       
33
       
+
       
    enable = mkEnableOption (lib.mdDoc "snipe-it, a free open source IT asset/license management system");

     

       
34
       
34
       
 
       


     

       
35
       
35
       
 
       
    user = mkOption {

     

       
36
       
36
       
 
       
      default = "snipeit";

     

···

       
9
       
9
       
 
       
  options.services.zitadel =

     

       
10
       
10
       
 
       
    let inherit (lib) mkEnableOption mkOption mkPackageOption types;

     

       
11
       
11
       
 
       
    in {

     

       
12
       
12
       
-
       
      enable = mkEnableOption "ZITADEL, a user and identity access management platform.";

     

       
12
       
12
       
+
       
      enable = mkEnableOption "ZITADEL, a user and identity access management platform";

     

       
13
       
13
       
 
       


     

       
14
       
14
       
 
       
      package = mkPackageOption pkgs "ZITADEL" { default = [ "zitadel" ]; };

     

       
15
       
15
       
 
       


     

···

       
16
       
16
       
 
       
  options.services.keter = {

     

       
17
       
17
       
 
       
    enable = lib.mkEnableOption (lib.mdDoc ''keter, a web app deployment manager.

     

       
18
       
18
       
 
       
Note that this module only support loading of webapps:

     

       
19
       
19
       
-
       
Keep an old app running and swap the ports when the new one is booted.

     

       
19
       
19
       
+
       
Keep an old app running and swap the ports when the new one is booted

     

       
20
       
20
       
 
       
'');

     

       
21
       
21
       
 
       


     

       
22
       
22
       
 
       
    root = lib.mkOption {

     

···

       
8
       
8
       
 
       


     

       
9
       
9
       
 
       
  options.services.rustus = {

     

       
10
       
10
       
 
       


     

       
11
       
11
       
-
       
    enable = mkEnableOption (lib.mdDoc "TUS protocol implementation in Rust.");

     

       
11
       
11
       
+
       
    enable = mkEnableOption (lib.mdDoc "TUS protocol implementation in Rust");

     

       
12
       
12
       
 
       


     

       
13
       
13
       
 
       
    host = mkOption {

     

       
14
       
14
       
 
       
      type = types.str;

     

···

       
15
       
15
       
 
       
  options = {

     

       
16
       
16
       
 
       


     

       
17
       
17
       
 
       
    services.xserver.desktopManager.deepin = {

     

       
18
       
18
       
-
       
      enable = mkEnableOption (lib.mdDoc "Enable Deepin desktop manager");

     

       
18
       
18
       
+
       
      enable = mkEnableOption (lib.mdDoc "Deepin desktop manager");

     

       
19
       
19
       
 
       
      extraGSettingsOverrides = mkOption {

     

       
20
       
20
       
 
       
        default = "";

     

       
21
       
21
       
 
       
        type = types.lines;

     

···

       
79
       
79
       
 
       
      // { default = true; internal = true; };

     

       
80
       
80
       
 
       
    enableValidation = lib.mkEnableOption (lib.mdDoc ''the validation of bootspec documents for each build.

     

       
81
       
81
       
 
       
      This will introduce Go in the build-time closure as we are relying on [Cuelang](https://cuelang.org/) for schema validation.

     

       
82
       
82
       
-
       
      Enable this option if you want to ascertain that your documents are correct.

     

       
82
       
82
       
+
       
      Enable this option if you want to ascertain that your documents are correct

     

       
83
       
83
       
 
       
      ''

     

       
84
       
84
       
 
       
    );

     

       
85
       
85
       
 
       


     

···

       
12
       
12
       
 
       
  ];

     

       
13
       
13
       
 
       


     

       
14
       
14
       
 
       
  options = {

     

       
15
       
15
       
-
       
    boot.growPartition = mkEnableOption (lib.mdDoc "grow the root partition on boot");

     

       
15
       
15
       
+
       
    boot.growPartition = mkEnableOption (lib.mdDoc "growing the root partition on boot");

     

       
16
       
16
       
 
       
  };

     

       
17
       
17
       
 
       


     

       
18
       
18
       
 
       
  config = mkIf config.boot.growPartition {

     

···

       
12
       
12
       
 
       
  };

     

       
13
       
13
       
 
       


     

       
14
       
14
       
 
       
  options.boot.loader.external = {

     

       
15
       
15
       
-
       
    enable = mkEnableOption (lib.mdDoc "use an external tool to install your bootloader");

     

       
15
       
15
       
+
       
    enable = mkEnableOption (lib.mdDoc "using an external tool to install your bootloader");

     

       
16
       
16
       
 
       


     

       
17
       
17
       
 
       
    installHook = mkOption {

     

       
18
       
18
       
 
       
      type = with types; path;

     

···

       
5
       
5
       
 
       
in

     

       
6
       
6
       
 
       
{

     

       
7
       
7
       
 
       
  options.services.homed.enable = lib.mkEnableOption (lib.mdDoc ''

     

       
8
       
8
       
-
       
    Enable systemd home area/user account manager

     

       
8
       
8
       
+
       
    systemd home area/user account manager

     

       
9
       
9
       
 
       
  '');

     

       
10
       
10
       
 
       


     

       
11
       
11
       
 
       
  config = lib.mkIf cfg.enable {

     

···

       
5
       
5
       
 
       
in

     

       
6
       
6
       
 
       
{

     

       
7
       
7
       
 
       
  options.services.userdbd.enable = lib.mkEnableOption (lib.mdDoc ''

     

       
8
       
8
       
-
       
    Enables the systemd JSON user/group record lookup service

     

       
8
       
8
       
+
       
    the systemd JSON user/group record lookup service

     

       
9
       
9
       
 
       
  '');

     

       
10
       
10
       
 
       
  config = lib.mkIf cfg.enable {

     

       
11
       
11
       
 
       
    systemd.additionalUpstreamSystemUnits = [