commit 4ba3f60b8aec1b8f05e5ab401b05a3192548a1c6 · pyrox.dev/nixpkgs

+1 -6

nixos/modules/programs/kubeswitch.nix

···

       18
       18
        
               description = "The name of the command to use";

     

       19
       19
        
             };

     

       20
       20
        
       

     

       21
       21
       -
             package = lib.mkOption {

     

       22
       22
       -
               type = lib.types.package;

     

       23
       23
       -
               default = pkgs.kubeswitch;

     

       24
       24
       -
               defaultText = lib.literalExpression "pkgs.kubeswitch";

     

       25
       25
       -
               description = "The package to install for kubeswitch";

     

       26
       26
       -
             };

     

       21
       21
       +
             package = lib.mkPackageOption pkgs "kubeswitch" { };

     

       27
       22
        
           };

     

       28
       23
        
         };

     

       29
       24

+1 -6

nixos/modules/security/tpm2.nix

···

       58
       58
        
               Trusted Platform 2 userspace resource manager daemon

     

       59
       59
        
             '';

     

       60
       60
        
       

     

       61
       61
       -
             package = lib.mkOption {

     

       62
       62
       -
               description = "tpm2-abrmd package to use";

     

       63
       63
       -
               type = lib.types.package;

     

       64
       64
       -
               default = pkgs.tpm2-abrmd;

     

       65
       65
       -
               defaultText = lib.literalExpression "pkgs.tpm2-abrmd";

     

       66
       66
       -
             };

     

       61
       61
       +
             package = lib.mkPackageOption pkgs "tpm2-abrmd" { };

     

       67
       62
        
           };

     

       68
       63
        
       

     

       69
       64
        
           pkcs11 = {

+1 -6

nixos/modules/services/continuous-integration/buildkite-agents.nix

···

       38
       38
        
                 description = "Whether to enable this buildkite agent";

     

       39
       39
        
               };

     

       40
       40
        
       

     

       41
       41
       -
               package = lib.mkOption {

     

       42
       42
       -
                 default = pkgs.buildkite-agent;

     

       43
       43
       -
                 defaultText = lib.literalExpression "pkgs.buildkite-agent";

     

       44
       44
       -
                 description = "Which buildkite-agent derivation to use";

     

       45
       45
       -
                 type = lib.types.package;

     

       46
       46
       -
               };

     

       41
       41
       +
               package = lib.mkPackageOption pkgs "buildkite-agent" { };

     

       47
       42
        
       

     

       48
       43
        
               dataDir = lib.mkOption {

     

       49
       44
        
                 default = "/var/lib/buildkite-agent-${name}";

+2 -8

nixos/modules/services/databases/chromadb.nix

···

       9
       9
        
         cfg = config.services.chromadb;

     

       10
       10
        
         inherit (lib)

     

       11
       11
        
           mkEnableOption

     

       12
       12
       +
           mkPackageOption

     

       12
       13
        
           mkOption

     

       13
       14
        
           mkIf

     

       14
       15
        
           types

     

       15
       15
       -
           literalExpression

     

       16
       16
        
           ;

     

       17
       17
        
       in

     

       18
       18
        
       {

     
···

       29
       29
        
           services.chromadb = {

     

       30
       30
        
             enable = mkEnableOption "ChromaDB, an open-source AI application database.";

     

       31
       31
        
       

     

       32
       32
       -
             package = mkOption {

     

       33
       33
       -
               type = types.package;

     

       34
       34
       -
               example = literalExpression "pkgs.python3Packages.chromadb";

     

       35
       35
       -
               default = pkgs.python3Packages.chromadb;

     

       36
       36
       -
               defaultText = "pkgs.python3Packages.chromadb";

     

       37
       37
       -
               description = "ChromaDB package to use.";

     

       38
       38
       -
             };

     

       32
       32
       +
             package = mkPackageOption pkgs [ "python3Packages" "chromadb" ] { };

     

       39
       33
        
       

     

       40
       34
        
             host = mkOption {

     

       41
       35
        
               type = types.str;

+1 -7

nixos/modules/services/databases/ferretdb.nix

···

       18
       18
        
           services.ferretdb = {

     

       19
       19
        
             enable = lib.mkEnableOption "FerretDB, an Open Source MongoDB alternative";

     

       20
       20
        
       

     

       21
       21
       -
             package = lib.mkOption {

     

       22
       22
       -
               type = lib.types.package;

     

       23
       23
       -
               example = lib.literalExpression "pkgs.ferretdb";

     

       24
       24
       -
               default = pkgs.ferretdb;

     

       25
       25
       -
               defaultText = "pkgs.ferretdb";

     

       26
       26
       -
               description = "FerretDB package to use.";

     

       27
       27
       -
             };

     

       21
       21
       +
             package = lib.mkPackageOption pkgs "ferretdb" { };

     

       28
       22
        
       

     

       29
       23
        
             settings = lib.mkOption {

     

       30
       24
        
               type = lib.types.submodule {

+1 -8

nixos/modules/services/development/lorri.nix

···

       21
       21
        
                 issued by the `lorri` command.

     

       22
       22
        
               '';

     

       23
       23
        
             };

     

       24
       24
       -
             package = lib.mkOption {

     

       25
       25
       -
               default = pkgs.lorri;

     

       26
       26
       -
               type = lib.types.package;

     

       27
       27
       -
               description = ''

     

       28
       28
       -
                 The lorri package to use.

     

       29
       29
       -
               '';

     

       30
       30
       -
               defaultText = lib.literalExpression "pkgs.lorri";

     

       31
       31
       -
             };

     

       24
       24
       +
             package = lib.mkPackageOption pkgs "lorri" { };

     

       32
       25
        
           };

     

       33
       26
        
         };

     

       34
       27

+1 -8

nixos/modules/services/hardware/argonone.nix

···

       11
       11
        
       {

     

       12
       12
        
         options.services.hardware.argonone = {

     

       13
       13
        
           enable = lib.mkEnableOption "the driver for Argon One Raspberry Pi case fan and power button";

     

       14
       14
       -
           package = lib.mkOption {

     

       15
       15
       -
             type = lib.types.package;

     

       16
       16
       -
             default = pkgs.argononed;

     

       17
       17
       -
             defaultText = lib.literalExpression "pkgs.argononed";

     

       18
       18
       -
             description = ''

     

       19
       19
       -
               The package implementing the Argon One driver

     

       20
       20
       -
             '';

     

       21
       21
       -
           };

     

       14
       14
       +
           package = lib.mkPackageOption pkgs "argononed" { };

     

       22
       15
        
         };

     

       23
       16
        
       

     

       24
       17
        
         config = lib.mkIf cfg.enable {

+1 -6

nixos/modules/services/hardware/sane.nix

···

       67
       67
        
             '';

     

       68
       68
        
           };

     

       69
       69
        
       

     

       70
       70
       -
           hardware.sane.backends-package = lib.mkOption {

     

       71
       71
       -
             type = lib.types.package;

     

       72
       72
       -
             default = pkgs.sane-backends;

     

       73
       73
       -
             defaultText = lib.literalExpression "pkgs.sane-backends";

     

       74
       74
       -
             description = "Backends driver package to use.";

     

       75
       75
       -
           };

     

       70
       70
       +
           hardware.sane.backends-package = lib.mkPackageOption pkgs "sane-backends" { };

     

       76
       71
        
       

     

       77
       72
        
           hardware.sane.snapshot = lib.mkOption {

     

       78
       73
        
             type = lib.types.bool;

+1 -8

nixos/modules/services/matrix/mautrix-discord.nix

···

       19
       19
        
           services.mautrix-discord = {

     

       20
       20
        
             enable = lib.mkEnableOption "Mautrix-Discord, a Matrix-Discord puppeting/relay-bot bridge";

     

       21
       21
        
       

     

       22
       22
       -
             package = lib.mkOption {

     

       23
       23
       -
               type = lib.types.package;

     

       24
       24
       -
               default = pkgs.mautrix-discord;

     

       25
       25
       -
               defaultText = lib.literalExpression "pkgs.mautrix-discord";

     

       26
       26
       -
               description = ''

     

       27
       27
       -
                 The mautrix-discord package to use.

     

       28
       28
       -
               '';

     

       29
       29
       -
             };

     

       22
       22
       +
             package = lib.mkPackageOption pkgs "mautrix-discord" { };

     

       30
       23
        
       

     

       31
       24
        
             settings = lib.mkOption {

     

       32
       25
        
               type = lib.types.submodule {

+1 -6

nixos/modules/services/misc/etebase-server.nix

···

       51
       51
        
               '';

     

       52
       52
        
             };

     

       53
       53
        
       

     

       54
       54
       -
             package = lib.mkOption {

     

       55
       55
       -
               type = lib.types.package;

     

       56
       56
       -
               default = pkgs.etebase-server;

     

       57
       57
       -
               defaultText = lib.literalExpression "pkgs.python3.pkgs.etebase-server";

     

       58
       58
       -
               description = "etebase-server package to use.";

     

       59
       59
       -
             };

     

       54
       54
       +
             package = lib.mkPackageOption pkgs "etebase-server" { };

     

       60
       55
        
       

     

       61
       56
        
             dataDir = lib.mkOption {

     

       62
       57
        
               type = lib.types.str;

+1 -8

nixos/modules/services/misc/invidious-router.nix

···

       70
       70
        
               for configuration options.

     

       71
       71
        
             '';

     

       72
       72
        
           };

     

       73
       73
       -
           package = lib.mkOption {

     

       74
       74
       -
             type = lib.types.package;

     

       75
       75
       -
             default = pkgs.invidious-router;

     

       76
       76
       -
             defaultText = lib.literalExpression "pkgs.invidious-router";

     

       77
       77
       -
             description = ''

     

       78
       78
       -
               The invidious-router package to use.

     

       79
       79
       -
             '';

     

       80
       80
       -
           };

     

       73
       73
       +
           package = lib.mkPackageOption pkgs "invidious-router" { };

     

       81
       74
        
           nginx = {

     

       82
       75
        
             enable = lib.mkEnableOption ''

     

       83
       76
        
               Automatic nginx proxy configuration

+1 -6

nixos/modules/services/misc/portunus.nix

···

       117
       117
        
           };

     

       118
       118
        
       

     

       119
       119
        
           ldap = {

     

       120
       120
       -
             package = lib.mkOption {

     

       121
       121
       -
               type = lib.types.package;

     

       122
       122
       -
               default = pkgs.openldap;

     

       123
       123
       -
               defaultText = lib.literalExpression "pkgs.openldap";

     

       124
       124
       -
               description = "The OpenLDAP package to use.";

     

       125
       125
       -
             };

     

       120
       120
       +
             package = lib.mkPackageOption pkgs "openldap" { };

     

       126
       121
        
       

     

       127
       122
        
             searchUserName = lib.mkOption {

     

       128
       123
        
               type = lib.types.str;

+2 -7

nixos/modules/services/networking/ax25/axlisten.nix

···

       17
       17
        
         inherit (lib.options)

     

       18
       18
        
           mkEnableOption

     

       19
       19
        
           mkOption

     

       20
       20
       -
           literalExpression

     

       20
       20
       +
           mkPackageOption

     

       21
       21
        
           ;

     

       22
       22
        
       

     

       23
       23
        
         cfg = config.services.ax25.axlisten;

     
···

       29
       29
        
       

     

       30
       30
        
             enable = mkEnableOption "AX.25 axlisten daemon";

     

       31
       31
        
       

     

       32
       32
       -
             package = mkOption {

     

       33
       33
       -
               type = types.package;

     

       34
       34
       -
               default = pkgs.ax25-apps;

     

       35
       35
       -
               defaultText = literalExpression "pkgs.ax25-apps";

     

       36
       36
       -
               description = "The ax25-apps package to use.";

     

       37
       37
       -
             };

     

       32
       32
       +
             package = mkPackageOption pkgs "ax25-apps" { };

     

       38
       33
        
       

     

       39
       34
        
             config = mkOption {

     

       40
       35
        
               type = types.str;

+1 -6

nixos/modules/services/networking/deconz.nix

···

       21
       21
        
       

     

       22
       22
        
           enable = lib.mkEnableOption "deCONZ, a Zigbee gateway for use with ConBee/RaspBee hardware (https://phoscon.de/)";

     

       23
       23
        
       

     

       24
       24
       -
           package = lib.mkOption {

     

       25
       25
       -
             type = lib.types.package;

     

       26
       26
       -
             default = pkgs.deconz;

     

       27
       27
       -
             defaultText = lib.literalExpression "pkgs.deconz";

     

       28
       28
       -
             description = "Which deCONZ package to use.";

     

       29
       29
       -
           };

     

       24
       24
       +
           package = lib.mkPackageOption pkgs "deconz" { };

     

       30
       25
        
       

     

       31
       26
        
           device = lib.mkOption {

     

       32
       27
        
             type = lib.types.nullOr lib.types.str;

+1 -8

nixos/modules/services/networking/firefox-syncserver.nix

···

       101
       101
        
               {option}`${opt.singleNode.enable}` does this automatically when enabled

     

       102
       102
        
             '';

     

       103
       103
        
       

     

       104
       104
       -
             package = lib.mkOption {

     

       105
       105
       -
               type = lib.types.package;

     

       106
       106
       -
               default = pkgs.syncstorage-rs;

     

       107
       107
       -
               defaultText = lib.literalExpression "pkgs.syncstorage-rs";

     

       108
       108
       -
               description = ''

     

       109
       109
       -
                 Package to use.

     

       110
       110
       -
               '';

     

       111
       111
       -
             };

     

       104
       104
       +
             package = lib.mkPackageOption pkgs "syncstorage-rs" { };

     

       112
       105
        
       

     

       113
       106
        
             database.name = lib.mkOption {

     

       114
       107
        
               # the mysql module does not allow `-quoting without resorting to shell

+1 -6

nixos/modules/services/networking/mycelium.nix

···

       39
       39
        
             default = false;

     

       40
       40
        
             description = "Open the firewall for mycelium";

     

       41
       41
        
           };

     

       42
       42
       -
           package = lib.mkOption {

     

       43
       43
       -
             type = lib.types.package;

     

       44
       44
       -
             default = pkgs.mycelium;

     

       45
       45
       -
             defaultText = lib.literalExpression ''"''${pkgs.mycelium}"'';

     

       46
       46
       -
             description = "The mycelium package to use";

     

       47
       47
       -
           };

     

       42
       42
       +
           package = lib.mkPackageOption pkgs "mycelium" { };

     

       48
       43
        
           addHostedPublicNodes = lib.mkOption {

     

       49
       44
        
             type = lib.types.bool;

     

       50
       45
        
             default = true;

+1 -8

nixos/modules/services/networking/onedrive.nix

···

       31
       31
        
         options.services.onedrive = {

     

       32
       32
        
           enable = lib.mkEnableOption "OneDrive service";

     

       33
       33
        
       

     

       34
       34
       -
           package = lib.mkOption {

     

       35
       35
       -
             type = lib.types.package;

     

       36
       36
       -
             default = pkgs.onedrive;

     

       37
       37
       -
             defaultText = lib.literalExpression "pkgs.onedrive";

     

       38
       38
       -
             description = ''

     

       39
       39
       -
               OneDrive package to use.

     

       40
       40
       -
             '';

     

       41
       41
       -
           };

     

       34
       34
       +
           package = lib.mkPackageOption pkgs "onedrive" { };

     

       42
       35
        
         };

     

       43
       36
        
         ### Implementation

     

       44
       37

+1 -6

nixos/modules/services/networking/shorewall.nix

···

       24
       24
        
                 :::

     

       25
       25
        
               '';

     

       26
       26
        
             };

     

       27
       27
       -
             package = lib.mkOption {

     

       28
       28
       -
               type = types.package;

     

       29
       29
       -
               default = pkgs.shorewall;

     

       30
       30
       -
               defaultText = lib.literalExpression "pkgs.shorewall";

     

       31
       31
       -
               description = "The shorewall package to use.";

     

       32
       32
       -
             };

     

       27
       27
       +
             package = lib.mkPackageOption pkgs "shorewall" { };

     

       33
       28
        
             configs = lib.mkOption {

     

       34
       29
        
               type = types.attrsOf types.lines;

     

       35
       30
        
               default = { };

+1 -6

nixos/modules/services/networking/shorewall6.nix

···

       24
       24
        
                 :::

     

       25
       25
        
               '';

     

       26
       26
        
             };

     

       27
       27
       -
             package = lib.mkOption {

     

       28
       28
       -
               type = types.package;

     

       29
       29
       -
               default = pkgs.shorewall;

     

       30
       30
       -
               defaultText = lib.literalExpression "pkgs.shorewall";

     

       31
       31
       -
               description = "The shorewall package to use.";

     

       32
       32
       -
             };

     

       27
       27
       +
             package = lib.mkPackageOption pkgs "shorewall" { };

     

       33
       28
        
             configs = lib.mkOption {

     

       34
       29
        
               type = types.attrsOf types.lines;

     

       35
       30
        
               default = { };

+1 -6

nixos/modules/services/networking/sitespeed-io.nix

···

       18
       18
        
             description = "User account under which sitespeed-io runs.";

     

       19
       19
        
           };

     

       20
       20
        
       

     

       21
       21
       -
           package = lib.mkOption {

     

       22
       22
       -
             type = lib.types.package;

     

       23
       23
       -
             default = pkgs.sitespeed-io;

     

       24
       24
       -
             defaultText = "pkgs.sitespeed-io";

     

       25
       25
       -
             description = "Sitespeed.io package to use.";

     

       26
       26
       -
           };

     

       21
       21
       +
           package = lib.mkPackageOption pkgs "sitespeed-io" { };

     

       27
       22
        
       

     

       28
       23
        
           dataDir = lib.mkOption {

     

       29
       24
        
             default = "/var/lib/sitespeed-io";

+1 -8

nixos/modules/services/networking/syncplay.nix

···

       290
       290
        
               '';

     

       291
       291
        
             };

     

       292
       292
        
       

     

       293
       293
       -
             package = mkOption {

     

       294
       294
       -
               type = types.package;

     

       295
       295
       -
               default = pkgs.syncplay-nogui;

     

       296
       296
       -
               defaultText = literalExpression "pkgs.syncplay-nogui";

     

       297
       297
       -
               description = ''

     

       298
       298
       -
                 Package to use for syncplay.

     

       299
       299
       -
               '';

     

       300
       300
       -
             };

     

       293
       293
       +
             package = mkPackageOption pkgs "syncplay-nogui" { };

     

       301
       294
        
           };

     

       302
       295
        
         };

     

       303
       296

+1 -8

nixos/modules/services/networking/x2goserver.nix

···

       37
       37
        
             '';

     

       38
       38
        
           };

     

       39
       39
        
       

     

       40
       40
       -
           package = mkOption {

     

       41
       41
       -
             type = types.package;

     

       42
       42
       -
             default = pkgs.x2goserver;

     

       43
       43
       -
             defaultText = literalExpression "pkgs.x2goserver";

     

       44
       44
       -
             description = ''

     

       45
       45
       -
               The x2goserver package to use.

     

       46
       46
       -
             '';

     

       47
       47
       -
           };

     

       40
       40
       +
           package = mkPackageOption pkgs "x2goserver" { };

     

       48
       41
        
       

     

       49
       42
        
           superenicer = {

     

       50
       43
        
             enable = mkEnableOption "superenicer" // {

+2 -6

nixos/modules/services/networking/zenohd.nix

···

       10
       10
        
           types

     

       11
       11
        
           mkDefault

     

       12
       12
        
           mkOption

     

       13
       13
       +
           mkPackageOption

     

       13
       14
        
           ;

     

       14
       15
        
       

     

       15
       16
        
         json = pkgs.formats.json { };

     
···

       22
       23
        
           services.zenohd = {

     

       23
       24
        
             enable = lib.mkEnableOption "Zenoh daemon.";

     

       24
       25
        
       

     

       25
       25
       -
             package = mkOption {

     

       26
       26
       -
               description = "The zenoh package to use.";

     

       27
       27
       -
               type = types.package;

     

       28
       28
       -
               default = pkgs.zenoh;

     

       29
       29
       -
               defaultText = "pkgs.zenoh";

     

       30
       30
       -
             };

     

       26
       26
       +
             package = mkPackageOption pkgs "zenoh" { };

     

       31
       27
        
       

     

       32
       28
        
             settings = mkOption {

     

       33
       29
        
               description = ''

+1 -6

nixos/modules/services/security/step-ca.nix

···

       15
       15
        
           services.step-ca = {

     

       16
       16
        
             enable = lib.mkEnableOption "the smallstep certificate authority server";

     

       17
       17
        
             openFirewall = lib.mkEnableOption "opening the certificate authority server port";

     

       18
       18
       -
             package = lib.mkOption {

     

       19
       19
       -
               type = lib.types.package;

     

       20
       20
       -
               default = pkgs.step-ca;

     

       21
       21
       -
               defaultText = lib.literalExpression "pkgs.step-ca";

     

       22
       22
       -
               description = "Which step-ca package to use.";

     

       23
       23
       -
             };

     

       18
       18
       +
             package = lib.mkPackageOption pkgs "step-ca" { };

     

       24
       19
        
             address = lib.mkOption {

     

       25
       20
        
               type = lib.types.str;

     

       26
       21
        
               example = "127.0.0.1";

+1 -6

nixos/modules/services/security/tang.nix

···

       11
       11
        
         options.services.tang = {

     

       12
       12
        
           enable = lib.mkEnableOption "tang";

     

       13
       13
        
       

     

       14
       14
       -
           package = lib.mkOption {

     

       15
       15
       -
             type = lib.types.package;

     

       16
       16
       -
             default = pkgs.tang;

     

       17
       17
       -
             defaultText = lib.literalExpression "pkgs.tang";

     

       18
       18
       -
             description = "The tang package to use.";

     

       19
       19
       -
           };

     

       14
       14
       +
           package = lib.mkPackageOption pkgs "tang" { };

     

       20
       15
        
       

     

       21
       16
        
           listenStream = lib.mkOption {

     

       22
       17
        
             type = with lib.types; listOf str;

+1 -6

nixos/modules/services/security/vaultwarden/default.nix

···

       197
       197
        
       

     

       198
       198
        
           package = lib.mkPackageOption pkgs "vaultwarden" { };

     

       199
       199
        
       

     

       200
       200
       -
           webVaultPackage = lib.mkOption {

     

       201
       201
       -
             type = lib.types.package;

     

       202
       202
       -
             default = pkgs.vaultwarden.webvault;

     

       203
       203
       -
             defaultText = lib.literalExpression "pkgs.vaultwarden.webvault";

     

       204
       204
       -
             description = "Web vault package to use.";

     

       205
       205
       -
           };

     

       200
       200
       +
           webVaultPackage = lib.mkPackageOption pkgs [ "vaultwarden" "webvault" ] { };

     

       206
       201
        
         };

     

       207
       202
        
       

     

       208
       203
        
         config = lib.mkIf cfg.enable {

+2 -17

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

···

       44
       44
        
                 Name of the nginx virtualhost to use and setup. If null, do not setup any virtualhost.

     

       45
       45
        
               '';

     

       46
       46
        
             };

     

       47
       47
       -
             phpPackage = lib.mkOption {

     

       48
       48
       -
               type = lib.types.package;

     

       49
       49
       -
               default = pkgs.php;

     

       50
       50
       -
               defaultText = "pkgs.php";

     

       51
       51
       -
               description = ''

     

       52
       52
       -
                 php package to use for php fpm daemon.

     

       53
       53
       -
               '';

     

       54
       54
       -
             };

     

       55
       55
       -
             package = lib.mkOption {

     

       56
       56
       -
               type = lib.types.package;

     

       57
       57
       -
               default = pkgs.baikal;

     

       58
       58
       -
               defaultText = "pkgs.baikal";

     

       59
       59
       -
               description = ''

     

       60
       60
       -
                 Baikal package to use.

     

       61
       61
       -
               '';

     

       62
       62
       -
             };

     

       63
       63
       -
       

     

       47
       47
       +
             phpPackage = lib.mkPackageOption pkgs "php" { };

     

       48
       48
       +
             package = lib.mkPackageOption pkgs "baikal" { };

     

       64
       49
        
           };

     

       65
       50
        
         };

     

       66
       51
        
         config = lib.mkIf cfg.enable {

+1 -6

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

···

       32
       32
        
         options.services = {

     

       33
       33
        
           castopod = {

     

       34
       34
        
             enable = lib.mkEnableOption "Castopod, a hosting platform for podcasters";

     

       35
       35
       -
             package = lib.mkOption {

     

       36
       36
       -
               type = lib.types.package;

     

       37
       37
       -
               default = pkgs.castopod;

     

       38
       38
       -
               defaultText = lib.literalMD "pkgs.castopod";

     

       39
       39
       -
               description = "Which Castopod package to use.";

     

       40
       40
       -
             };

     

       35
       35
       +
             package = lib.mkPackageOption pkgs "castopod" { };

     

       41
       36
        
             dataDir = lib.mkOption {

     

       42
       37
        
               type = lib.types.path;

     

       43
       38
        
               default = "/var/lib/castopod";

+1 -6

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

···

       706
       706
        
               };

     

       707
       707
        
             };

     

       708
       708
        
       

     

       709
       709
       -
             package = lib.mkOption {

     

       710
       710
       -
               type = lib.types.package;

     

       711
       711
       -
               default = pkgs.mastodon;

     

       712
       712
       -
               defaultText = lib.literalExpression "pkgs.mastodon";

     

       713
       713
       -
               description = "Mastodon package to use.";

     

       714
       714
       -
             };

     

       709
       709
       +
             package = lib.mkPackageOption pkgs "mastodon" { };

     

       715
       710
        
       

     

       716
       711
        
             extraConfig = lib.mkOption {

     

       717
       712
        
               type = lib.types.attrs;

+1 -6

nixos/modules/services/web-apps/nextcloud-notify_push.nix

···

       14
       14
        
         options.services.nextcloud.notify_push = {

     

       15
       15
        
           enable = lib.mkEnableOption "Notify push";

     

       16
       16
        
       

     

       17
       17
       -
           package = lib.mkOption {

     

       18
       18
       -
             type = lib.types.package;

     

       19
       19
       -
             default = pkgs.nextcloud-notify_push;

     

       20
       20
       -
             defaultText = lib.literalMD "pkgs.nextcloud-notify_push";

     

       21
       21
       -
             description = "Which package to use for notify_push";

     

       22
       22
       -
           };

     

       17
       17
       +
           package = lib.mkPackageOption pkgs "nextcloud-notify_push" { };

     

       23
       18
        
       

     

       24
       19
        
           socketPath = lib.mkOption {

     

       25
       20
        
             type = lib.types.str;

+1 -6

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

···

       37
       37
        
           services.nifi = {

     

       38
       38
        
             enable = lib.mkEnableOption "Apache NiFi";

     

       39
       39
        
       

     

       40
       40
       -
             package = lib.mkOption {

     

       41
       41
       -
               type = lib.types.package;

     

       42
       42
       -
               default = pkgs.nifi;

     

       43
       43
       -
               defaultText = lib.literalExpression "pkgs.nifi";

     

       44
       44
       -
               description = "Apache NiFi package to use.";

     

       45
       45
       -
             };

     

       40
       40
       +
             package = lib.mkPackageOption pkgs "nifi" { };

     

       46
       41
        
       

     

       47
       42
        
             user = lib.mkOption {

     

       48
       43
        
               type = lib.types.str;

+1 -6

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

···

       338
       338
        
             };

     

       339
       339
        
           };

     

       340
       340
        
       

     

       341
       341
       -
           package = lib.mkOption {

     

       342
       342
       -
             type = lib.types.package;

     

       343
       343
       -
             default = pkgs.peertube;

     

       344
       344
       -
             defaultText = lib.literalExpression "pkgs.peertube";

     

       345
       345
       -
             description = "PeerTube package to use.";

     

       346
       346
       -
           };

     

       341
       341
       +
           package = lib.mkPackageOption pkgs "peertube" { };

     

       347
       342
        
         };

     

       348
       343
        
       

     

       349
       344
        
         config = lib.mkIf cfg.enable {

+1 -6

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

···

       152
       152
        
         options.services.writefreely = {

     

       153
       153
        
           enable = lib.mkEnableOption "Writefreely, build a digital writing community";

     

       154
       154
        
       

     

       155
       155
       -
           package = lib.mkOption {

     

       156
       156
       -
             type = lib.types.package;

     

       157
       157
       -
             default = pkgs.writefreely;

     

       158
       158
       -
             defaultText = lib.literalExpression "pkgs.writefreely";

     

       159
       159
       -
             description = "Writefreely package to use.";

     

       160
       160
       -
           };

     

       155
       155
       +
           package = lib.mkPackageOption pkgs "writefreely" { };

     

       161
       156
        
       

     

       162
       157
        
           stateDir = mkOption {

     

       163
       158
        
             type = types.path;

+1 -8

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

···

       51
       51
        
             type = lib.types.str;

     

       52
       52
        
           };

     

       53
       53
        
       

     

       54
       54
       -
           package = lib.mkOption {

     

       55
       55
       -
             description = ''

     

       56
       56
       -
               Package to use.

     

       57
       57
       -
             '';

     

       58
       58
       -
             type = lib.types.package;

     

       59
       59
       -
             default = pkgs.youtrack;

     

       60
       60
       -
             defaultText = lib.literalExpression "pkgs.youtrack";

     

       61
       61
       -
           };

     

       54
       54
       +
           package = lib.mkPackageOption pkgs "youtrack" { };

     

       62
       55
        
       

     

       63
       56
        
           statePath = lib.mkOption {

     

       64
       57
        
             description = ''

+1 -6

nixos/modules/services/web-servers/keter/default.nix

···

       31
       31
        
             description = "Mutable state folder for keter";

     

       32
       32
        
           };

     

       33
       33
        
       

     

       34
       34
       -
           package = lib.mkOption {

     

       35
       35
       -
             type = lib.types.package;

     

       36
       36
       -
             default = pkgs.haskellPackages.keter;

     

       37
       37
       -
             defaultText = lib.literalExpression "pkgs.haskellPackages.keter";

     

       38
       38
       -
             description = "The keter package to be used";

     

       39
       39
       -
           };

     

       34
       34
       +
           package = lib.mkPackageOption pkgs [ "haskellPackages" "keter" ] { };

     

       40
       35
        
       

     

       41
       36
        
           globalKeterConfig = lib.mkOption {

     

       42
       37
        
             type = lib.types.submodule {

+3 -27

nixos/modules/services/x11/display-managers/lightdm-greeters/enso-os.nix

···

       38
       38
        
             };

     

       39
       39
        
       

     

       40
       40
        
             theme = {

     

       41
       41
       -
               package = mkOption {

     

       42
       42
       -
                 type = types.package;

     

       43
       43
       -
                 default = pkgs.gnome-themes-extra;

     

       44
       44
       -
                 defaultText = literalExpression "pkgs.gnome-themes-extra";

     

       45
       45
       -
                 description = ''

     

       46
       46
       -
                   The package path that contains the theme given in the name option.

     

       47
       47
       -
                 '';

     

       48
       48
       -
               };

     

       49
       49
       -
       

     

       41
       41
       +
               package = mkPackageOption pkgs "gnome-themes-extra" { };

     

       50
       42
        
               name = mkOption {

     

       51
       43
        
                 type = types.str;

     

       52
       44
        
                 default = "Adwaita";

     
···

       57
       49
        
             };

     

       58
       50
        
       

     

       59
       51
        
             iconTheme = {

     

       60
       60
       -
               package = mkOption {

     

       61
       61
       -
                 type = types.package;

     

       62
       62
       -
                 default = pkgs.papirus-icon-theme;

     

       63
       63
       -
                 defaultText = literalExpression "pkgs.papirus-icon-theme";

     

       64
       64
       -
                 description = ''

     

       65
       65
       -
                   The package path that contains the icon theme given in the name option.

     

       66
       66
       -
                 '';

     

       67
       67
       -
               };

     

       68
       68
       -
       

     

       52
       52
       +
               package = mkPackageOption pkgs "papirus-icon-theme" { };

     

       69
       53
        
               name = mkOption {

     

       70
       54
        
                 type = types.str;

     

       71
       55
        
                 default = "ePapirus";

     
···

       76
       60
        
             };

     

       77
       61
        
       

     

       78
       62
        
             cursorTheme = {

     

       79
       79
       -
               package = mkOption {

     

       80
       80
       -
                 type = types.package;

     

       81
       81
       -
                 default = pkgs.capitaine-cursors;

     

       82
       82
       -
                 defaultText = literalExpression "pkgs.capitaine-cursors";

     

       83
       83
       -
                 description = ''

     

       84
       84
       -
                   The package path that contains the cursor theme given in the name option.

     

       85
       85
       -
                 '';

     

       86
       86
       -
               };

     

       87
       87
       -
       

     

       63
       63
       +
               package = mkPackageOption pkgs "capitaine-cursors" { };

     

       88
       64
        
               name = mkOption {

     

       89
       65
        
                 type = types.str;

     

       90
       66
        
                 default = "capitane-cursors";

+3 -24

nixos/modules/services/x11/display-managers/lightdm-greeters/gtk.nix

···

       49
       49
        
       

     

       50
       50
        
             theme = {

     

       51
       51
        
       

     

       52
       52
       -
               package = mkOption {

     

       53
       53
       -
                 type = types.package;

     

       54
       54
       -
                 default = pkgs.gnome-themes-extra;

     

       55
       55
       -
                 defaultText = literalExpression "pkgs.gnome-themes-extra";

     

       56
       56
       -
                 description = ''

     

       57
       57
       -
                   The package path that contains the theme given in the name option.

     

       58
       58
       -
                 '';

     

       59
       59
       -
               };

     

       52
       52
       +
               package = mkPackageOption pkgs "gnome-themes-extra" { };

     

       60
       53
        
       

     

       61
       54
        
               name = mkOption {

     

       62
       55
        
                 type = types.str;

     
···

       70
       63
        
       

     

       71
       64
        
             iconTheme = {

     

       72
       65
        
       

     

       73
       73
       -
               package = mkOption {

     

       74
       74
       -
                 type = types.package;

     

       75
       75
       -
                 default = pkgs.adwaita-icon-theme;

     

       76
       76
       -
                 defaultText = literalExpression "pkgs.adwaita-icon-theme";

     

       77
       77
       -
                 description = ''

     

       78
       78
       -
                   The package path that contains the icon theme given in the name option.

     

       79
       79
       -
                 '';

     

       80
       80
       -
               };

     

       66
       66
       +
               package = mkPackageOption pkgs "adwaita-icon-theme" { };

     

       81
       67
        
       

     

       82
       68
        
               name = mkOption {

     

       83
       69
        
                 type = types.str;

     
···

       91
       77
        
       

     

       92
       78
        
             cursorTheme = {

     

       93
       79
        
       

     

       94
       94
       -
               package = mkOption {

     

       95
       95
       -
                 type = types.package;

     

       96
       96
       -
                 default = pkgs.adwaita-icon-theme;

     

       97
       97
       -
                 defaultText = literalExpression "pkgs.adwaita-icon-theme";

     

       98
       98
       -
                 description = ''

     

       99
       99
       -
                   The package path that contains the cursor theme given in the name option.

     

       100
       100
       -
                 '';

     

       101
       101
       -
               };

     

       80
       80
       +
               package = mkPackageOption pkgs "adwaita-icon-theme" { };

     

       102
       81
        
       

     

       103
       82
        
               name = mkOption {

     

       104
       83
        
                 type = types.str;

+4 -32

nixos/modules/services/x11/display-managers/lightdm-greeters/slick.nix

···

       36
       36
        
             enable = mkEnableOption "lightdm-slick-greeter as the lightdm greeter";

     

       37
       37
        
       

     

       38
       38
        
             theme = {

     

       39
       39
       -
               package = mkOption {

     

       40
       40
       -
                 type = types.package;

     

       41
       41
       -
                 default = pkgs.gnome-themes-extra;

     

       42
       42
       -
                 defaultText = literalExpression "pkgs.gnome-themes-extra";

     

       43
       43
       -
                 description = ''

     

       44
       44
       -
                   The package path that contains the theme given in the name option.

     

       45
       45
       -
                 '';

     

       46
       46
       -
               };

     

       39
       39
       +
               package = mkPackageOption pkgs "gnome-themes-extra" { };

     

       47
       40
        
       

     

       48
       41
        
               name = mkOption {

     

       49
       42
        
                 type = types.str;

     
···

       55
       48
        
             };

     

       56
       49
        
       

     

       57
       50
        
             iconTheme = {

     

       58
       58
       -
               package = mkOption {

     

       59
       59
       -
                 type = types.package;

     

       60
       60
       -
                 default = pkgs.adwaita-icon-theme;

     

       61
       61
       -
                 defaultText = literalExpression "pkgs.adwaita-icon-theme";

     

       62
       62
       -
                 description = ''

     

       63
       63
       -
                   The package path that contains the icon theme given in the name option.

     

       64
       64
       -
                 '';

     

       65
       65
       -
               };

     

       51
       51
       +
               package = mkPackageOption pkgs "adwaita-icon-theme" { };

     

       66
       52
        
       

     

       67
       53
        
               name = mkOption {

     

       68
       54
        
                 type = types.str;

     
···

       74
       60
        
             };

     

       75
       61
        
       

     

       76
       62
        
             font = {

     

       77
       77
       -
               package = mkOption {

     

       78
       78
       -
                 type = types.package;

     

       79
       79
       -
                 default = pkgs.ubuntu-classic;

     

       80
       80
       -
                 defaultText = literalExpression "pkgs.ubuntu-classic";

     

       81
       81
       -
                 description = ''

     

       82
       82
       -
                   The package path that contains the font given in the name option.

     

       83
       83
       -
                 '';

     

       84
       84
       -
               };

     

       63
       63
       +
               package = mkPackageOption pkgs "ubuntu-classic" { };

     

       85
       64
        
       

     

       86
       65
        
               name = mkOption {

     

       87
       66
        
                 type = types.str;

     
···

       93
       72
        
             };

     

       94
       73
        
       

     

       95
       74
        
             cursorTheme = {

     

       96
       96
       -
               package = mkOption {

     

       97
       97
       -
                 type = types.package;

     

       98
       98
       -
                 default = pkgs.adwaita-icon-theme;

     

       99
       99
       -
                 defaultText = literalExpression "pkgs.adwaita-icon-theme";

     

       100
       100
       -
                 description = ''

     

       101
       101
       -
                   The package path that contains the cursor theme given in the name option.

     

       102
       102
       -
                 '';

     

       103
       103
       -
               };

     

       75
       75
       +
               package = mkPackageOption pkgs "adwaita-icon-theme" { };

     

       104
       76
        
       

     

       105
       77
        
               name = mkOption {

     

       106
       78
        
                 type = types.str;

+1 -6

nixos/modules/services/x11/window-managers/nimdow.nix

···

       13
       13
        
       {

     

       14
       14
        
         options = {

     

       15
       15
        
           services.xserver.windowManager.nimdow.enable = mkEnableOption "nimdow";

     

       16
       16
       -
           services.xserver.windowManager.nimdow.package = mkOption {

     

       17
       17
       -
             type = types.package;

     

       18
       18
       -
             default = pkgs.nimdow;

     

       19
       19
       -
             defaultText = "pkgs.nimdow";

     

       20
       20
       -
             description = "nimdow package to use";

     

       21
       21
       -
           };

     

       16
       16
       +
           services.xserver.windowManager.nimdow.package = mkPackageOption pkgs "nimdow" { };

     

       22
       17
        
         };

     

       23
       18
        
       

     

       24
       19
        
         config = mkIf cfg.enable {

+1 -6

nixos/modules/services/x11/xscreensaver.nix

···

       12
       12
        
         options.services.xscreensaver = {

     

       13
       13
        
           enable = lib.mkEnableOption "xscreensaver user service";

     

       14
       14
        
       

     

       15
       15
       -
           package = lib.mkOption {

     

       16
       16
       -
             type = lib.types.package;

     

       17
       17
       -
             default = pkgs.xscreensaver;

     

       18
       18
       -
             defaultText = lib.literalExpression "pkgs.xscreensaver";

     

       19
       19
       -
             description = "Which xscreensaver package to use.";

     

       20
       20
       -
           };

     

       15
       15
       +
           package = lib.mkPackageOption pkgs "xscreensaver" { };

     

       21
       16
        
         };

     

       22
       17
        
       

     

       23
       18
        
         config = lib.mkIf cfg.enable {

+1 -6

nixos/modules/system/boot/clevis.nix

···

       22
       22
        
         options = {

     

       23
       23
        
           boot.initrd.clevis.enable = lib.mkEnableOption "Clevis in initrd";

     

       24
       24
        
       

     

       25
       25
       -
           boot.initrd.clevis.package = lib.mkOption {

     

       26
       26
       -
             type = lib.types.package;

     

       27
       27
       -
             default = pkgs.clevis;

     

       28
       28
       -
             defaultText = "pkgs.clevis";

     

       29
       29
       -
             description = "Clevis package";

     

       30
       30
       -
           };

     

       25
       25
       +
           boot.initrd.clevis.package = lib.mkPackageOption pkgs "clevis" { };

     

       31
       26
        
       

     

       32
       27
        
           boot.initrd.clevis.devices = lib.mkOption {

     

       33
       28
        
             description = "Encrypted devices that need to be unlocked at boot using Clevis";