commit b4674b39c1928f05118ea0c1c4fb8ab66190edd6 · pyrox.dev/nixpkgs

+2 -3

nixos/modules/hardware/brillo.nix

···

       8
        
         options = {

     

       9
        
           hardware.brillo = {

     

       10
        
             enable = mkEnableOption (lib.mdDoc ''

     

       11
       -
               Enable brillo in userspace.

     

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

     

       13
        
             '');

     

       14
        
           };

     

       15
        
         };

     

       16
       -
       

     

       17
        
       

     

       18
        
         config = mkIf cfg.enable {

     

       19
        
           services.udev.packages = [ pkgs.brillo ];

···

       8
        
         options = {

     

       9
        
           hardware.brillo = {

     

       10
        
             enable = mkEnableOption (lib.mdDoc ''

     

       11
       +
               brillo in userspace.

     

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

     

       13
        
             '');

     

       14
        
           };

     

       15
        
         };

     

       0
        
       
     

       16
        
       

     

       17
        
         config = mkIf cfg.enable {

     

       18
        
           services.udev.packages = [ pkgs.brillo ];

+1 -1

nixos/modules/hardware/ubertooth.nix

···

       10
        
         };

     

       11
        
       in {

     

       12
        
         options.hardware.ubertooth = {

     

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

     

       14
        
       

     

       15
        
           group = mkOption {

     

       16
        
             type = types.str;

···

       10
        
         };

     

       11
        
       in {

     

       12
        
         options.hardware.ubertooth = {

     

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

     

       14
        
       

     

       15
        
           group = mkOption {

     

       16
        
             type = types.str;

+1 -1

nixos/modules/hardware/wooting.nix

···

       3
        
       with lib;

     

       4
        
       {

     

       5
        
         options.hardware.wooting.enable =

     

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

     

       7
        
       

     

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

     

       9
        
           environment.systemPackages = [ pkgs.wootility ];

···

       3
        
       with lib;

     

       4
        
       {

     

       5
        
         options.hardware.wooting.enable =

     

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

     

       7
        
       

     

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

     

       9
        
           environment.systemPackages = [ pkgs.wootility ];

+1 -1

nixos/modules/programs/kclock.nix

···

       4
        
         cfg = config.programs.kclock;

     

       5
        
         kclockPkg = pkgs.libsForQt5.kclock;

     

       6
        
       in {

     

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

     

       8
        
       

     

       9
        
         config = mkIf cfg.enable {

     

       10
        
           services.dbus.packages = [ kclockPkg ];

···

       4
        
         cfg = config.programs.kclock;

     

       5
        
         kclockPkg = pkgs.libsForQt5.kclock;

     

       6
        
       in {

     

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

     

       8
        
       

     

       9
        
         config = mkIf cfg.enable {

     

       10
        
           services.dbus.packages = [ kclockPkg ];

+1 -1

nixos/modules/services/cluster/kubernetes/flannel.nix

···

       12
        
       {

     

       13
        
         ###### interface

     

       14
        
         options.services.kubernetes.flannel = {

     

       15
       -
           enable = mkEnableOption (lib.mdDoc "enable flannel networking");

     

       16
        
         };

     

       17
        
       

     

       18
        
         ###### implementation

···

       12
        
       {

     

       13
        
         ###### interface

     

       14
        
         options.services.kubernetes.flannel = {

     

       15
       +
           enable = mkEnableOption (lib.mdDoc "flannel networking");

     

       16
        
         };

     

       17
        
       

     

       18
        
         ###### implementation

+1 -1

nixos/modules/services/computing/foldingathome/client.nix

···

       18
        
           '')

     

       19
        
         ];

     

       20
        
         options.services.foldingathome = {

     

       21
       -
           enable = mkEnableOption (lib.mdDoc "Enable the Folding@home client");

     

       22
        
       

     

       23
        
           package = mkOption {

     

       24
        
             type = types.package;

···

       18
        
           '')

     

       19
        
         ];

     

       20
        
         options.services.foldingathome = {

     

       21
       +
           enable = mkEnableOption (lib.mdDoc "Folding@home client");

     

       22
        
       

     

       23
        
           package = mkOption {

     

       24
        
             type = types.package;

+1 -7

nixos/modules/services/databases/couchdb.nix

···

       34
        
       

     

       35
        
           services.couchdb = {

     

       36
        
       

     

       37
       -
             enable = mkOption {

     

       38
       -
               type = types.bool;

     

       39
       -
               default = false;

     

       40
       -
               description = lib.mdDoc ''

     

       41
       -
                 Whether to run CouchDB Server.

     

       42
       -
               '';

     

       43
       -
             };

     

       44
        
       

     

       45
        
             package = mkOption {

     

       46
        
               type = types.package;

···

       34
        
       

     

       35
        
           services.couchdb = {

     

       36
        
       

     

       37
       +
             enable = mkEnableOption (lib.mdDoc "CouchDB Server");

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       38
        
       

     

       39
        
             package = mkOption {

     

       40
        
               type = types.package;

+1 -7

nixos/modules/services/databases/opentsdb.nix

···

       15
        
       

     

       16
        
           services.opentsdb = {

     

       17
        
       

     

       18
       -
             enable = mkOption {

     

       19
       -
               type = types.bool;

     

       20
       -
               default = false;

     

       21
       -
               description = lib.mdDoc ''

     

       22
       -
                 Whether to run OpenTSDB.

     

       23
       -
               '';

     

       24
       -
             };

     

       25
        
       

     

       26
        
             package = mkOption {

     

       27
        
               type = types.package;

···

       15
        
       

     

       16
        
           services.opentsdb = {

     

       17
        
       

     

       18
       +
             enable = mkEnableOption (lib.mdDoc "OpenTSDB");

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       19
        
       

     

       20
        
             package = mkOption {

     

       21
        
               type = types.package;

+1 -1

nixos/modules/services/home-automation/zigbee2mqtt.nix

···

       18
        
         ];

     

       19
        
       

     

       20
        
         options.services.zigbee2mqtt = {

     

       21
       -
           enable = mkEnableOption (lib.mdDoc "enable zigbee2mqtt service");

     

       22
        
       

     

       23
        
           package = mkOption {

     

       24
        
             description = lib.mdDoc "Zigbee2mqtt package to use";

···

       18
        
         ];

     

       19
        
       

     

       20
        
         options.services.zigbee2mqtt = {

     

       21
       +
           enable = mkEnableOption (lib.mdDoc "zigbee2mqtt service");

     

       22
        
       

     

       23
        
           package = mkOption {

     

       24
        
             description = lib.mdDoc "Zigbee2mqtt package to use";

+1 -5

nixos/modules/services/logging/fluentd.nix

···

       12
        
         options = {

     

       13
        
       

     

       14
        
           services.fluentd = {

     

       15
       -
             enable = mkOption {

     

       16
       -
               type = types.bool;

     

       17
       -
               default = false;

     

       18
       -
               description = lib.mdDoc "Whether to enable fluentd.";

     

       19
       -
             };

     

       20
        
       

     

       21
        
             config = mkOption {

     

       22
        
               type = types.lines;

···

       12
        
         options = {

     

       13
        
       

     

       14
        
           services.fluentd = {

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       16
        
       

     

       17
        
             config = mkOption {

     

       18
        
               type = types.lines;

+1 -7

nixos/modules/services/logging/logcheck.nix

···

       109
        
       {

     

       110
        
         options = {

     

       111
        
           services.logcheck = {

     

       112
       -
             enable = mkOption {

     

       113
       -
               default = false;

     

       114
       -
               type = types.bool;

     

       115
       -
               description = lib.mdDoc ''

     

       116
       -
                 Enable the logcheck cron job.

     

       117
       -
               '';

     

       118
       -
             };

     

       119
        
       

     

       120
        
             user = mkOption {

     

       121
        
               default = "logcheck";

···

       109
        
       {

     

       110
        
         options = {

     

       111
        
           services.logcheck = {

     

       112
       +
             enable = mkEnableOption (lib.mdDoc "logcheck cron job");

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       113
        
       

     

       114
        
             user = mkOption {

     

       115
        
               default = "logcheck";

+2 -7

nixos/modules/services/misc/exhibitor.nix

···

       68
        
       {

     

       69
        
         options = {

     

       70
        
           services.exhibitor = {

     

       71
       -
             enable = mkOption {

     

       72
       -
               type = types.bool;

     

       73
       -
               default = false;

     

       74
       -
               description = lib.mdDoc ''

     

       75
       -
                 Whether to enable the exhibitor server.

     

       76
       -
               '';

     

       77
       -
             };

     

       78
        
             # See https://github.com/soabase/exhibitor/wiki/Running-Exhibitor for what these mean

     

       79
        
             # General options for any type of config

     

       80
        
             port = mkOption {

···

       68
        
       {

     

       69
        
         options = {

     

       70
        
           services.exhibitor = {

     

       71
       +
             enable = mkEnableOption (lib.mdDoc "exhibitor server");

     

       72
       +
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       73
        
             # See https://github.com/soabase/exhibitor/wiki/Running-Exhibitor for what these mean

     

       74
        
             # General options for any type of config

     

       75
        
             port = mkOption {

+1 -5

nixos/modules/services/misc/gollum.nix

···

       8
        
       

     

       9
        
       {

     

       10
        
         options.services.gollum = {

     

       11
       -
           enable = mkOption {

     

       12
       -
             type = types.bool;

     

       13
       -
             default = false;

     

       14
       -
             description = lib.mdDoc "Enable the Gollum service.";

     

       15
       -
           };

     

       16
        
       

     

       17
        
           address = mkOption {

     

       18
        
             type = types.str;

···

       8
        
       

     

       9
        
       {

     

       10
        
         options.services.gollum = {

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       12
        
       

     

       13
        
           address = mkOption {

     

       14
        
             type = types.str;

+1 -5

nixos/modules/services/misc/zookeeper.nix

···

       24
        
       in {

     

       25
        
       

     

       26
        
         options.services.zookeeper = {

     

       27
       -
           enable = mkOption {

     

       28
       -
             description = lib.mdDoc "Whether to enable Zookeeper.";

     

       29
       -
             default = false;

     

       30
       -
             type = types.bool;

     

       31
       -
           };

     

       32
        
       

     

       33
        
           port = mkOption {

     

       34
        
             description = lib.mdDoc "Zookeeper Client port.";

···

       24
        
       in {

     

       25
        
       

     

       26
        
         options.services.zookeeper = {

     

       27
       +
           enable = mkEnableOption (lib.mdDoc "Zookeeper");

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       28
        
       

     

       29
        
           port = mkOption {

     

       30
        
             description = lib.mdDoc "Zookeeper Client port.";

+1 -7

nixos/modules/services/monitoring/arbtt.nix

···

       7
        
       in {

     

       8
        
         options = {

     

       9
        
           services.arbtt = {

     

       10
       -
             enable = mkOption {

     

       11
       -
               type = types.bool;

     

       12
       -
               default = false;

     

       13
       -
               description = lib.mdDoc ''

     

       14
       -
                 Enable the arbtt statistics capture service.

     

       15
       -
               '';

     

       16
       -
             };

     

       17
        
       

     

       18
        
             package = mkOption {

     

       19
        
               type = types.package;

···

       7
        
       in {

     

       8
        
         options = {

     

       9
        
           services.arbtt = {

     

       10
       +
             enable = mkEnableOption (lib.mdDoc "Arbtt statistics capture service");

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       11
        
       

     

       12
        
             package = mkOption {

     

       13
        
               type = types.package;

+1 -7

nixos/modules/services/monitoring/bosun.nix

···

       22
        
       

     

       23
        
           services.bosun = {

     

       24
        
       

     

       25
       -
             enable = mkOption {

     

       26
       -
               type = types.bool;

     

       27
       -
               default = false;

     

       28
       -
               description = lib.mdDoc ''

     

       29
       -
                 Whether to run bosun.

     

       30
       -
               '';

     

       31
       -
             };

     

       32
        
       

     

       33
        
             package = mkOption {

     

       34
        
               type = types.package;

···

       22
        
       

     

       23
        
           services.bosun = {

     

       24
        
       

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       26
        
       

     

       27
        
             package = mkOption {

     

       28
        
               type = types.package;

+1 -5

nixos/modules/services/monitoring/cadvisor.nix

···

       8
        
       in {

     

       9
        
         options = {

     

       10
        
           services.cadvisor = {

     

       11
       -
             enable = mkOption {

     

       12
       -
               default = false;

     

       13
       -
               type = types.bool;

     

       14
       -
               description = lib.mdDoc "Whether to enable cadvisor service.";

     

       15
       -
             };

     

       16
        
       

     

       17
        
             listenAddress = mkOption {

     

       18
        
               default = "127.0.0.1";

···

       8
        
       in {

     

       9
        
         options = {

     

       10
        
           services.cadvisor = {

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       12
        
       

     

       13
        
             listenAddress = mkOption {

     

       14
        
               default = "127.0.0.1";

+1 -7

nixos/modules/services/monitoring/datadog-agent.nix

···

       49
        
         };

     

       50
        
       in {

     

       51
        
         options.services.datadog-agent = {

     

       52
       -
           enable = mkOption {

     

       53
       -
             description = lib.mdDoc ''

     

       54
       -
               Whether to enable the datadog-agent v7 monitoring service

     

       55
       -
             '';

     

       56
       -
             default = false;

     

       57
       -
             type = types.bool;

     

       58
       -
           };

     

       59
        
       

     

       60
        
           package = mkOption {

     

       61
        
             default = pkgs.datadog-agent;

···

       49
        
         };

     

       50
        
       in {

     

       51
        
         options.services.datadog-agent = {

     

       52
       +
           enable = mkEnableOption (lib.mdDoc "Datadog-agent v7 monitoring service");

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       53
        
       

     

       54
        
           package = mkOption {

     

       55
        
             default = pkgs.datadog-agent;

+1 -5

nixos/modules/services/monitoring/heapster.nix

···

       6
        
         cfg = config.services.heapster;

     

       7
        
       in {

     

       8
        
         options.services.heapster = {

     

       9
       -
           enable = mkOption {

     

       10
       -
             description = lib.mdDoc "Whether to enable heapster monitoring";

     

       11
       -
             default = false;

     

       12
       -
             type = types.bool;

     

       13
       -
           };

     

       14
        
       

     

       15
        
           source = mkOption {

     

       16
        
             description = lib.mdDoc "Heapster metric source";

···

       6
        
         cfg = config.services.heapster;

     

       7
        
       in {

     

       8
        
         options.services.heapster = {

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       10
        
       

     

       11
        
           source = mkOption {

     

       12
        
             description = lib.mdDoc "Heapster metric source";

+1 -7

nixos/modules/services/monitoring/prometheus/default.nix

···

       1563
        
       

     

       1564
        
         options.services.prometheus = {

     

       1565
        
       

     

       1566
       -
           enable = mkOption {

     

       1567
       -
             type = types.bool;

     

       1568
       -
             default = false;

     

       1569
       -
             description = lib.mdDoc ''

     

       1570
       -
               Enable the Prometheus monitoring daemon.

     

       1571
       -
             '';

     

       1572
       -
           };

     

       1573
        
       

     

       1574
        
           package = mkOption {

     

       1575
        
             type = types.package;

···

       1563
        
       

     

       1564
        
         options.services.prometheus = {

     

       1565
        
       

     

       1566
       +
           enable = mkEnableOption (lib.mdDoc "Prometheus monitoring daemon");

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1567
        
       

     

       1568
        
           package = mkOption {

     

       1569
        
             type = types.package;

+2 -7

nixos/modules/services/monitoring/riemann.nix

···

       27
        
         options = {

     

       28
        
       

     

       29
        
           services.riemann = {

     

       30
       -
             enable = mkOption {

     

       31
       -
               type = types.bool;

     

       32
       -
               default = false;

     

       33
       -
               description = lib.mdDoc ''

     

       34
       -
                 Enable the Riemann network monitoring daemon.

     

       35
       -
               '';

     

       36
       -
             };

     

       37
        
             config = mkOption {

     

       38
        
               type = types.lines;

     

       39
        
               description = lib.mdDoc ''

···

       27
        
         options = {

     

       28
        
       

     

       29
        
           services.riemann = {

     

       30
       +
             enable = mkEnableOption (lib.mdDoc "Riemann network monitoring daemon");

     

       31
       +
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       32
        
             config = mkOption {

     

       33
        
               type = types.lines;

     

       34
        
               description = lib.mdDoc ''

+1 -1

nixos/modules/services/network-filesystems/samba-wsdd.nix

···

       9
        
         options = {

     

       10
        
           services.samba-wsdd = {

     

       11
        
             enable = mkEnableOption (lib.mdDoc ''

     

       12
       -
               Enable Web Services Dynamic Discovery host daemon. This enables (Samba) hosts, like your local NAS device,

     

       13
        
               to be found by Web Service Discovery Clients like Windows.

     

       14
        
       

     

       15
        
               ::: {.note}

···

       9
        
         options = {

     

       10
        
           services.samba-wsdd = {

     

       11
        
             enable = mkEnableOption (lib.mdDoc ''

     

       12
       +
               Web Services Dynamic Discovery host daemon. This enables (Samba) hosts, like your local NAS device,

     

       13
        
               to be found by Web Service Discovery Clients like Windows.

     

       14
        
       

     

       15
        
               ::: {.note}

+1 -1

nixos/modules/services/networking/magic-wormhole-mailbox-server.nix

···

       9
        
       in

     

       10
        
       {

     

       11
        
         options.services.magic-wormhole-mailbox-server = {

     

       12
       -
           enable = mkEnableOption (lib.mdDoc "Enable Magic Wormhole Mailbox Server");

     

       13
        
         };

     

       14
        
       

     

       15
        
         config = mkIf cfg.enable {

···

       9
        
       in

     

       10
        
       {

     

       11
        
         options.services.magic-wormhole-mailbox-server = {

     

       12
       +
           enable = mkEnableOption (lib.mdDoc "Magic Wormhole Mailbox Server");

     

       13
        
         };

     

       14
        
       

     

       15
        
         config = mkIf cfg.enable {

+2 -7

nixos/modules/services/networking/mozillavpn.nix

···

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

     

       2
        
       

     

       3
        
       {

     

       4
       -
         options.services.mozillavpn.enable = lib.mkOption {

     

       5
       -
           type = lib.types.bool;

     

       6
       -
           default = false;

     

       7
       -
           description = lib.mdDoc ''

     

       8
       -
             Enable the Mozilla VPN daemon.

     

       9
       -
           '';

     

       10
       -
         };

     

       11
        
       

     

       12
        
         config = lib.mkIf config.services.mozillavpn.enable {

     

       13
        
           environment.systemPackages = [ pkgs.mozillavpn ];

···

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

     

       2
        
       

     

       3
        
       {

     

       4
       +
         options.services.mozillavpn.enable =

     

       5
       +
           lib.mkEnableOption (lib.mdDoc "Mozilla VPN daemon");

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       6
        
       

     

       7
        
         config = lib.mkIf config.services.mozillavpn.enable {

     

       8
        
           environment.systemPackages = [ pkgs.mozillavpn ];

+1 -1

nixos/modules/services/networking/networkmanager.nix

···

       365
        
                 If you enable this option the

     

       366
        
                 `networkmanager_strongswan` plugin will be added to

     

       367
        
                 the {option}`networking.networkmanager.plugins` option

     

       368
       -
                 so you don't need to to that yourself.

     

       369
        
               '';

     

       370
        
             };

     

       371

···

       365
        
                 If you enable this option the

     

       366
        
                 `networkmanager_strongswan` plugin will be added to

     

       367
        
                 the {option}`networking.networkmanager.plugins` option

     

       368
       +
                 so you don't need to do that yourself.

     

       369
        
               '';

     

       370
        
             };

     

       371

+1 -5

nixos/modules/services/networking/onedrive.nix

···

       26
        
         ### Interface

     

       27
        
       

     

       28
        
         options.services.onedrive = {

     

       29
       -
           enable = lib.mkOption {

     

       30
       -
             type = lib.types.bool;

     

       31
       -
             default = false;

     

       32
       -
             description = lib.mdDoc "Enable OneDrive service";

     

       33
       -
           };

     

       34
        
       

     

       35
        
            package = lib.mkOption {

     

       36
        
              type = lib.types.package;

···

       26
        
         ### Interface

     

       27
        
       

     

       28
        
         options.services.onedrive = {

     

       29
       +
            enable = lib.mkEnableOption (lib.mdDoc "OneDrive service");

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       30
        
       

     

       31
        
            package = lib.mkOption {

     

       32
        
              type = lib.types.package;

+1 -1

nixos/modules/services/networking/owamp.nix

···

       10
        
         ###### interface

     

       11
        
       

     

       12
        
         options = {

     

       13
       -
           services.owamp.enable = mkEnableOption (lib.mdDoc "Enable OWAMP server");

     

       14
        
         };

     

       15
        
       

     

       16

···

       10
        
         ###### interface

     

       11
        
       

     

       12
        
         options = {

     

       13
       +
           services.owamp.enable = mkEnableOption (lib.mdDoc "OWAMP server");

     

       14
        
         };

     

       15
        
       

     

       16

+1 -5

nixos/modules/services/networking/polipo.nix

···

       23
        
       

     

       24
        
           services.polipo = {

     

       25
        
       

     

       26
       -
             enable = mkOption {

     

       27
       -
               type = types.bool;

     

       28
       -
               default = false;

     

       29
       -
               description = lib.mdDoc "Whether to run the polipo caching web proxy.";

     

       30
       -
             };

     

       31
        
       

     

       32
        
             proxyAddress = mkOption {

     

       33
        
               type = types.str;

···

       23
        
       

     

       24
        
           services.polipo = {

     

       25
        
       

     

       26
       +
             enable = mkEnableOption (lib.mdDoc "polipo caching web proxy");

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       27
        
       

     

       28
        
             proxyAddress = mkOption {

     

       29
        
               type = types.str;

+2 -5

nixos/modules/services/networking/smokeping.nix

···

       49
        
       {

     

       50
        
         options = {

     

       51
        
           services.smokeping = {

     

       52
       -
             enable = mkOption {

     

       53
       -
               type = types.bool;

     

       54
       -
               default = false;

     

       55
       -
               description = lib.mdDoc "Enable the smokeping service";

     

       56
       -
             };

     

       57
        
             alertConfig = mkOption {

     

       58
        
               type = types.lines;

     

       59
        
               default = ''

···

       49
        
       {

     

       50
        
         options = {

     

       51
        
           services.smokeping = {

     

       52
       +
             enable = mkEnableOption (lib.mdDoc "smokeping service");

     

       53
       +
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       54
        
             alertConfig = mkOption {

     

       55
        
               type = types.lines;

     

       56
        
               default = ''

+1 -1

nixos/modules/services/web-apps/peertube.nix

···

       75
        
       

     

       76
        
       in {

     

       77
        
         options.services.peertube = {

     

       78
       -
           enable = lib.mkEnableOption (lib.mdDoc "Enable Peertube’s service");

     

       79
        
       

     

       80
        
           user = lib.mkOption {

     

       81
        
             type = lib.types.str;

···

       75
        
       

     

       76
        
       in {

     

       77
        
         options.services.peertube = {

     

       78
       +
           enable = lib.mkEnableOption (lib.mdDoc "Peertube");

     

       79
        
       

     

       80
        
           user = lib.mkOption {

     

       81
        
             type = lib.types.str;

+1 -7

nixos/modules/services/x11/clight.nix

···

       28
        
             cfg.settings));

     

       29
        
       in {

     

       30
        
         options.services.clight = {

     

       31
       -
           enable = mkOption {

     

       32
       -
             type = types.bool;

     

       33
       -
             default = false;

     

       34
       -
             description = lib.mdDoc ''

     

       35
       -
               Whether to enable clight or not.

     

       36
       -
             '';

     

       37
       -
           };

     

       38
        
       

     

       39
        
           temperature = {

     

       40
        
             day = mkOption {

···

       28
        
             cfg.settings));

     

       29
        
       in {

     

       30
        
         options.services.clight = {

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       32
        
       

     

       33
        
           temperature = {

     

       34
        
             day = mkOption {