commit 79d3d59f58cccc6c1d167b8f6b8b6bd27b663aa7 · pyrox.dev/nixpkgs

+1 -1

nixos/modules/programs/_1password-gui.nix

···

       27
       27
        
               '';

     

       28
       28
        
             };

     

       29
       29
        
       

     

       30
       30
       -
             package = mkPackageOptionMD pkgs "1Password GUI" {

     

       30
       30
       +
             package = mkPackageOption pkgs "1Password GUI" {

     

       31
       31
        
               default = [ "_1password-gui" ];

     

       32
       32
        
             };

     

       33
       33
        
           };

+1 -1

nixos/modules/programs/_1password.nix

···

       18
       18
        
           programs._1password = {

     

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

     

       20
       20
        
       

     

       21
       21
       -
             package = mkPackageOptionMD pkgs "1Password CLI" {

     

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

     

       22
       22
        
               default = [ "_1password" ];

     

       23
       23
        
             };

     

       24
       24
        
           };

+1 -1

nixos/modules/programs/darling.nix

···

       6
       6
        
         options = {

     

       7
       7
        
           programs.darling = {

     

       8
       8
        
             enable = lib.mkEnableOption (lib.mdDoc "Darling, a Darwin/macOS compatibility layer for Linux");

     

       9
       9
       -
             package = lib.mkPackageOptionMD pkgs "darling" {};

     

       9
       9
       +
             package = lib.mkPackageOption pkgs "darling" {};

     

       10
       10
        
           };

     

       11
       11
        
         };

     

       12
       12

+2 -2

nixos/modules/programs/direnv.nix

···

       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" {};

     

       17
       17
       +
           package = lib.mkPackageOption pkgs "direnv" {};

     

       18
       18
        
       

     

       19
       19
        
           direnvrcExtra = lib.mkOption {

     

       20
       20
        
             type = lib.types.lines;

     
···

       49
       49
        
                 default = true;

     

       50
       50
        
               };

     

       51
       51
        
       

     

       52
       52
       -
             package = lib.mkPackageOptionMD pkgs "nix-direnv" {};

     

       52
       52
       +
             package = lib.mkPackageOption pkgs "nix-direnv" {};

     

       53
       53
        
           };

     

       54
       54
        
         };

     

       55
       55

+1 -1

nixos/modules/programs/flashrom.nix

···

       16
       16
        
               group.

     

       17
       17
        
             '';

     

       18
       18
        
           };

     

       19
       19
       -
           package = mkPackageOptionMD pkgs "flashrom" { };

     

       19
       19
       +
           package = mkPackageOption pkgs "flashrom" { };

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
        
         config = mkIf cfg.enable {

+2 -2

nixos/modules/programs/hyprland.nix

···

       23
       23
        
             '';

     

       24
       24
        
           };

     

       25
       25
        
       

     

       26
       26
       -
           package = mkPackageOptionMD pkgs "hyprland" { };

     

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

     

       27
       27
        
       

     

       28
       28
        
           finalPackage = mkOption {

     

       29
       29
        
             type = types.package;

     
···

       39
       39
        
             '';

     

       40
       40
        
           };

     

       41
       41
        
       

     

       42
       42
       -
           portalPackage = mkPackageOptionMD pkgs "xdg-desktop-portal-hyprland" { };

     

       42
       42
       +
           portalPackage = mkPackageOption pkgs "xdg-desktop-portal-hyprland" { };

     

       43
       43
        
       

     

       44
       44
        
           xwayland.enable = mkEnableOption (mdDoc "XWayland") // { default = true; };

     

       45
       45

+2 -2

nixos/modules/programs/iay.nix

···

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         cfg = config.programs.iay;

     

       5
       5
       -
         inherit (lib) mkEnableOption mkIf mkOption mkPackageOptionMD optionalString types;

     

       5
       5
       +
         inherit (lib) mkEnableOption mkIf mkOption mkPackageOption optionalString types;

     

       6
       6
        
       in {

     

       7
       7
        
         options.programs.iay = {

     

       8
       8
        
           enable = mkEnableOption (lib.mdDoc "iay");

     

       9
       9
       -
           package = mkPackageOptionMD pkgs "iay" {};

     

       9
       9
       +
           package = mkPackageOption pkgs "iay" {};

     

       10
       10
        
       

     

       11
       11
        
           minimalPrompt = mkOption {

     

       12
       12
        
             type = types.bool;

+1 -1

nixos/modules/programs/minipro.nix

···

       13
       13
        
               '';

     

       14
       14
        
             };

     

       15
       15
        
       

     

       16
       16
       -
             package = lib.mkPackageOptionMD pkgs "minipro" { };

     

       16
       16
       +
             package = lib.mkPackageOption pkgs "minipro" { };

     

       17
       17
        
           };

     

       18
       18
        
         };

     

       19
       19

+1 -1

nixos/modules/programs/nano.nix

···

       11
       11
        
               default = true;

     

       12
       12
        
             };

     

       13
       13
        
       

     

       14
       14
       -
             package = lib.mkPackageOptionMD pkgs "nano" { };

     

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

     

       15
       15
        
       

     

       16
       16
        
             nanorc = lib.mkOption {

     

       17
       17
        
               type = lib.types.lines;

+1 -1

nixos/modules/programs/nexttrace.nix

···

       8
       8
        
         options = {

     

       9
       9
        
           programs.nexttrace = {

     

       10
       10
        
             enable = lib.mkEnableOption (lib.mdDoc "Nexttrace to the global environment and configure a setcap wrapper for it");

     

       11
       11
       -
             package = lib.mkPackageOptionMD pkgs "nexttrace" { };

     

       11
       11
       +
             package = lib.mkPackageOption pkgs "nexttrace" { };

     

       12
       12
        
           };

     

       13
       13
        
         };

     

       14
       14

+1 -1

nixos/modules/programs/nix-ld.nix

···

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

     

       38
       38
        
         options.programs.nix-ld = {

     

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

     

       40
       40
       -
           package = lib.mkPackageOptionMD pkgs "nix-ld" { };

     

       40
       40
       +
           package = lib.mkPackageOption pkgs "nix-ld" { };

     

       41
       41
        
           libraries = lib.mkOption {

     

       42
       42
        
             type = lib.types.listOf lib.types.package;

     

       43
       43
        
             description = lib.mdDoc "Libraries that automatically become available to all programs. The default set includes common libraries.";

+1 -1

nixos/modules/programs/projecteur.nix

···

       6
       6
        
       {

     

       7
       7
        
         options.programs.projecteur = {

     

       8
       8
        
           enable = lib.mkEnableOption (lib.mdDoc "projecteur");

     

       9
       9
       -
           package = lib.mkPackageOptionMD pkgs "projecteur" { };

     

       9
       9
       +
           package = lib.mkPackageOption pkgs "projecteur" { };

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         config = lib.mkIf cfg.enable {

+1 -1

nixos/modules/programs/qdmr.nix

···

       13
       13
        
         options = {

     

       14
       14
        
           programs.qdmr = {

     

       15
       15
        
             enable = lib.mkEnableOption (lib.mdDoc "QDMR - a GUI application and command line tool for programming DMR radios");

     

       16
       16
       -
             package = lib.mkPackageOptionMD pkgs "qdmr" { };

     

       16
       16
       +
             package = lib.mkPackageOption pkgs "qdmr" { };

     

       17
       17
        
           };

     

       18
       18
        
         };

     

       19
       19

+1 -1

nixos/modules/programs/regreet.nix

···

       24
       24
        
             '';

     

       25
       25
        
           };

     

       26
       26
        
       

     

       27
       27
       -
           package = lib.mkPackageOptionMD pkgs [ "greetd" "regreet" ] { };

     

       27
       27
       +
           package = lib.mkPackageOption pkgs [ "greetd" "regreet" ] { };

     

       28
       28
        
       

     

       29
       29
        
           settings = lib.mkOption {

     

       30
       30
        
             type = lib.types.either lib.types.path settingsFormat.type;

+1 -1

nixos/modules/programs/shadow.nix

···

       7
       7
        
       {

     

       8
       8
        
         options = with types; {

     

       9
       9
        
           security.loginDefs = {

     

       10
       10
       -
             package = mkPackageOptionMD pkgs "shadow" { };

     

       10
       10
       +
             package = mkPackageOption pkgs "shadow" { };

     

       11
       11
        
       

     

       12
       12
        
             chfnRestrict = mkOption {

     

       13
       13
        
               description = mdDoc ''

+2 -2

nixos/modules/programs/skim.nix

···

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

     

       2
       2
        
       let

     

       3
       3
       -
         inherit (lib) mdDoc mkEnableOption mkPackageOptionMD optional optionalString;

     

       3
       3
       +
         inherit (lib) mdDoc mkEnableOption mkPackageOption optional optionalString;

     

       4
       4
        
         cfg = config.programs.skim;

     

       5
       5
        
       in

     

       6
       6
        
       {

     
···

       8
       8
        
           programs.skim = {

     

       9
       9
        
             fuzzyCompletion = mkEnableOption (mdDoc "fuzzy completion with skim");

     

       10
       10
        
             keybindings = mkEnableOption (mdDoc "skim keybindings");

     

       11
       11
       -
             package = mkPackageOptionMD pkgs "skim" {};

     

       11
       11
       +
             package = mkPackageOption pkgs "skim" {};

     

       12
       12
        
           };

     

       13
       13
        
         };

     

       14
       14

+1 -1

nixos/modules/programs/streamdeck-ui.nix

···

       15
       15
        
             description = lib.mdDoc "Whether streamdeck-ui should be started automatically.";

     

       16
       16
        
           };

     

       17
       17
        
       

     

       18
       18
       -
           package = mkPackageOptionMD pkgs "streamdeck-ui" {

     

       18
       18
       +
           package = mkPackageOption pkgs "streamdeck-ui" {

     

       19
       19
        
             default = [ "streamdeck-ui" ];

     

       20
       20
        
           };

     

       21
       21

+1 -1

nixos/modules/programs/wayland/cardboard.nix

···

       9
       9
        
         options.programs.cardboard = {

     

       10
       10
        
           enable = lib.mkEnableOption (lib.mdDoc "cardboard");

     

       11
       11
        
       

     

       12
       12
       -
           package = lib.mkPackageOptionMD pkgs "cardboard" { };

     

       12
       12
       +
           package = lib.mkPackageOption pkgs "cardboard" { };

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         config = lib.mkIf cfg.enable (lib.mkMerge [

+1 -1

nixos/modules/programs/wayland/waybar.nix

···

       8
       8
        
       {

     

       9
       9
        
         options.programs.waybar = {

     

       10
       10
        
           enable = mkEnableOption (lib.mdDoc "waybar");

     

       11
       11
       -
           package = mkPackageOptionMD pkgs "waybar" { };

     

       11
       11
       +
           package = mkPackageOption pkgs "waybar" { };

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         config = mkIf cfg.enable {

+1 -1

nixos/modules/programs/wayland/wayfire.nix

···

       8
       8
        
         options.programs.wayfire = {

     

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

     

       10
       10
        
       

     

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

     

       11
       11
       +
           package = lib.mkPackageOption pkgs "wayfire" { };

     

       12
       12
        
       

     

       13
       13
        
           plugins = lib.mkOption {

     

       14
       14
        
             type = lib.types.listOf lib.types.package;

+1 -1

nixos/modules/programs/yazi.nix

···

       11
       11
        
         options.programs.yazi = {

     

       12
       12
        
           enable = lib.mkEnableOption (lib.mdDoc "yazi terminal file manager");

     

       13
       13
        
       

     

       14
       14
       -
           package = lib.mkPackageOptionMD pkgs "yazi" { };

     

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

     

       15
       15
        
       

     

       16
       16
        
           settings = lib.mkOption {

     

       17
       17
        
             type = with lib.types; submodule {

+1 -1

nixos/modules/services/audio/gmediarender.nix

···

       41
       41
        
             '';

     

       42
       42
        
           };

     

       43
       43
        
       

     

       44
       44
       -
           package = mkPackageOptionMD pkgs "gmediarender" {

     

       44
       44
       +
           package = mkPackageOption pkgs "gmediarender" {

     

       45
       45
        
             default = "gmrender-resurrect";

     

       46
       46
        
           };

     

       47
       47

+1 -1

nixos/modules/services/audio/goxlr-utility.nix

···

       16
       16
        
                 Whether to enable goxlr-utility for controlling your TC-Helicon GoXLR or GoXLR Mini

     

       17
       17
        
               '';

     

       18
       18
        
             };

     

       19
       19
       -
             package = mkPackageOptionMD pkgs "goxlr-utility" { };

     

       19
       19
       +
             package = mkPackageOption pkgs "goxlr-utility" { };

     

       20
       20
        
             autoStart.xdg = mkOption {

     

       21
       21
        
               default = true;

     

       22
       22
        
               type = with types; bool;

+1 -1

nixos/modules/services/audio/navidrome.nix

···

       11
       11
        
       

     

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

     

       13
       13
        
       

     

       14
       14
       -
             package = mkPackageOptionMD pkgs "navidrome" { };

     

       14
       14
       +
             package = mkPackageOption pkgs "navidrome" { };

     

       15
       15
        
       

     

       16
       16
        
             settings = mkOption rec {

     

       17
       17
        
               type = settingsFormat.type;

+2 -2

nixos/modules/services/audio/wyoming/faster-whisper.nix

···

       12
       12
        
           mkOption

     

       13
       13
        
           mdDoc

     

       14
       14
        
           mkEnableOption

     

       15
       15
       -
           mkPackageOptionMD

     

       15
       15
       +
           mkPackageOption

     

       16
       16
        
           types

     

       17
       17
        
           ;

     

       18
       18
        
       

     
···

       24
       24
        
       

     

       25
       25
        
       {

     

       26
       26
        
         options.services.wyoming.faster-whisper = with types; {

     

       27
       27
       -
           package = mkPackageOptionMD pkgs "wyoming-faster-whisper" { };

     

       27
       27
       +
           package = mkPackageOption pkgs "wyoming-faster-whisper" { };

     

       28
       28
        
       

     

       29
       29
        
           servers = mkOption {

     

       30
       30
        
             default = {};

+2 -2

nixos/modules/services/audio/wyoming/openwakeword.nix

···

       15
       15
        
           mdDoc

     

       16
       16
        
           mkEnableOption

     

       17
       17
        
           mkIf

     

       18
       18
       -
           mkPackageOptionMD

     

       18
       18
       +
           mkPackageOption

     

       19
       19
        
           mkRemovedOptionModule

     

       20
       20
        
           types

     

       21
       21
        
           ;

     
···

       36
       36
        
         options.services.wyoming.openwakeword = with types; {

     

       37
       37
        
           enable = mkEnableOption (mdDoc "Wyoming openWakeWord server");

     

       38
       38
        
       

     

       39
       39
       -
           package = mkPackageOptionMD pkgs "wyoming-openwakeword" { };

     

       39
       39
       +
           package = mkPackageOption pkgs "wyoming-openwakeword" { };

     

       40
       40
        
       

     

       41
       41
        
           uri = mkOption {

     

       42
       42
        
             type = strMatching "^(tcp|unix)://.*$";

+3 -3

nixos/modules/services/audio/wyoming/piper.nix

···

       12
       12
        
           mkOption

     

       13
       13
        
           mdDoc

     

       14
       14
        
           mkEnableOption

     

       15
       15
       -
           mkPackageOptionMD

     

       15
       15
       +
           mkPackageOption

     

       16
       16
        
           types

     

       17
       17
        
           ;

     

       18
       18
        
       

     
···

       26
       26
        
         meta.buildDocsInSandbox = false;

     

       27
       27
        
       

     

       28
       28
        
         options.services.wyoming.piper = with types; {

     

       29
       29
       -
           package = mkPackageOptionMD pkgs "wyoming-piper" { };

     

       29
       29
       +
           package = mkPackageOption pkgs "wyoming-piper" { };

     

       30
       30
        
       

     

       31
       31
        
           servers = mkOption {

     

       32
       32
        
             default = {};

     
···

       38
       38
        
                 options = {

     

       39
       39
        
                   enable = mkEnableOption (mdDoc "Wyoming Piper server");

     

       40
       40
        
       

     

       41
       41
       -
                   piper = mkPackageOptionMD pkgs "piper-tts" { };

     

       41
       41
       +
                   piper = mkPackageOption pkgs "piper-tts" { };

     

       42
       42
        
       

     

       43
       43
        
                   voice = mkOption {

     

       44
       44
        
                     type = str;

+1 -1

nixos/modules/services/backup/borgbackup.nix

···

       231
       231
        
       

     

       232
       232
        
         ###### interface

     

       233
       233
        
       

     

       234
       234
       -
         options.services.borgbackup.package = mkPackageOptionMD pkgs "borgbackup" { };

     

       234
       234
       +
         options.services.borgbackup.package = mkPackageOption pkgs "borgbackup" { };

     

       235
       235
        
       

     

       236
       236
        
         options.services.borgbackup.jobs = mkOption {

     

       237
       237
        
           description = lib.mdDoc ''

+1 -1

nixos/modules/services/backup/duplicati.nix

···

       10
       10
        
           services.duplicati = {

     

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

     

       12
       12
        
       

     

       13
       13
       -
             package = mkPackageOptionMD pkgs "duplicati" { };

     

       13
       13
       +
             package = mkPackageOption pkgs "duplicati" { };

     

       14
       14
        
       

     

       15
       15
        
             port = mkOption {

     

       16
       16
        
               default = 8200;

+1 -1

nixos/modules/services/backup/sanoid.nix

···

       114
       114
        
         options.services.sanoid = {

     

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

     

       116
       116
        
       

     

       117
       117
       -
           package = lib.mkPackageOptionMD pkgs "sanoid" {};

     

       117
       117
       +
           package = lib.mkPackageOption pkgs "sanoid" {};

     

       118
       118
        
       

     

       119
       119
        
           interval = mkOption {

     

       120
       120
        
             type = types.str;

+1 -1

nixos/modules/services/backup/syncoid.nix

···

       87
       87
        
         options.services.syncoid = {

     

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

     

       89
       89
        
       

     

       90
       90
       -
           package = lib.mkPackageOptionMD pkgs "sanoid" {};

     

       90
       90
       +
           package = lib.mkPackageOption pkgs "sanoid" {};

     

       91
       91
        
       

     

       92
       92
        
           interval = mkOption {

     

       93
       93
        
             type = types.str;

+1 -1

nixos/modules/services/blockchain/ethereum/erigon.nix

···

       13
       13
        
           services.erigon = {

     

       14
       14
        
             enable = mkEnableOption (lib.mdDoc "Ethereum implementation on the efficiency frontier");

     

       15
       15
        
       

     

       16
       16
       -
             package = mkPackageOptionMD pkgs "erigon" { };

     

       16
       16
       +
             package = mkPackageOption pkgs "erigon" { };

     

       17
       17
        
       

     

       18
       18
        
             extraArgs = mkOption {

     

       19
       19
        
               type = types.listOf types.str;

+2 -2

nixos/modules/services/continuous-integration/gitea-actions-runner.nix

···

       19
       19
        
           mapAttrs'

     

       20
       20
        
           mkEnableOption

     

       21
       21
        
           mkOption

     

       22
       22
       -
           mkPackageOptionMD

     

       22
       22
       +
           mkPackageOption

     

       23
       23
        
           mkIf

     

       24
       24
        
           nameValuePair

     

       25
       25
        
           types

     
···

       56
       56
        
         ];

     

       57
       57
        
       

     

       58
       58
        
         options.services.gitea-actions-runner = with types; {

     

       59
       59
       -
           package = mkPackageOptionMD pkgs "gitea-actions-runner" { };

     

       59
       59
       +
           package = mkPackageOption pkgs "gitea-actions-runner" { };

     

       60
       60
        
       

     

       61
       61
        
           instances = mkOption {

     

       62
       62
        
             default = {};

+1 -1

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

···

       11
       11
        
           options = {

     

       12
       12
        
             enable = lib.mkEnableOption (lib.mdDoc "this Woodpecker-Agent. Agents execute tasks generated by a Server, every install will need one server and at least one agent");

     

       13
       13
        
       

     

       14
       14
       -
             package = lib.mkPackageOptionMD pkgs "woodpecker-agent" { };

     

       14
       14
       +
             package = lib.mkPackageOption pkgs "woodpecker-agent" { };

     

       15
       15
        
       

     

       16
       16
        
             environment = lib.mkOption {

     

       17
       17
        
               default = { };

+1 -1

nixos/modules/services/continuous-integration/woodpecker/server.nix

···

       14
       14
        
         options = {

     

       15
       15
        
           services.woodpecker-server = {

     

       16
       16
        
             enable = lib.mkEnableOption (lib.mdDoc "the Woodpecker-Server, a CI/CD application for automatic builds, deployments and tests");

     

       17
       17
       -
             package = lib.mkPackageOptionMD pkgs "woodpecker-server" { };

     

       17
       17
       +
             package = lib.mkPackageOption pkgs "woodpecker-server" { };

     

       18
       18
        
             environment = lib.mkOption {

     

       19
       19
        
               default = { };

     

       20
       20
        
               type = lib.types.attrsOf lib.types.str;

+1 -1

nixos/modules/services/databases/dgraph.nix

···

       55
       55
        
           services.dgraph = {

     

       56
       56
        
             enable = mkEnableOption (lib.mdDoc "Dgraph native GraphQL database with a graph backend");

     

       57
       57
        
       

     

       58
       58
       -
             package = lib.mkPackageOptionMD pkgs "dgraph" { };

     

       58
       58
       +
             package = lib.mkPackageOption pkgs "dgraph" { };

     

       59
       59
        
       

     

       60
       60
        
             settings = mkOption {

     

       61
       61
        
               type = settingsFormat.type;

+1 -1

nixos/modules/services/databases/lldap.nix

···

       8
       8
        
         options.services.lldap = with lib; {

     

       9
       9
        
           enable = mkEnableOption (mdDoc "lldap");

     

       10
       10
        
       

     

       11
       11
       -
           package = mkPackageOptionMD pkgs "lldap" { };

     

       11
       11
       +
           package = mkPackageOption pkgs "lldap" { };

     

       12
       12
        
       

     

       13
       13
        
           environment = mkOption {

     

       14
       14
        
             type = with types; attrsOf str;

+1 -1

nixos/modules/services/games/openarena.nix

···

       8
       8
        
         options = {

     

       9
       9
        
           services.openarena = {

     

       10
       10
        
             enable = mkEnableOption (lib.mdDoc "OpenArena");

     

       11
       11
       -
             package = lib.mkPackageOptionMD pkgs "openarena" { };

     

       11
       11
       +
             package = lib.mkPackageOption pkgs "openarena" { };

     

       12
       12
        
       

     

       13
       13
        
             openPorts = mkOption {

     

       14
       14
        
               type = types.bool;

+1 -1

nixos/modules/services/games/quake3-server.nix

···

       41
       41
        
         options = {

     

       42
       42
        
           services.quake3-server = {

     

       43
       43
        
             enable = mkEnableOption (lib.mdDoc "Quake 3 dedicated server");

     

       44
       44
       -
             package = lib.mkPackageOptionMD pkgs "ioquake3" { };

     

       44
       44
       +
             package = lib.mkPackageOption pkgs "ioquake3" { };

     

       45
       45
        
       

     

       46
       46
        
             port = mkOption {

     

       47
       47
        
               type = types.port;

+2 -2

nixos/modules/services/home-automation/homeassistant-satellite.nix

···

       14
       14
        
           mdDoc

     

       15
       15
        
           mkEnableOption

     

       16
       16
        
           mkIf

     

       17
       17
       -
           mkPackageOptionMD

     

       17
       17
       +
           mkPackageOption

     

       18
       18
        
           types

     

       19
       19
        
           ;

     

       20
       20
        
       

     
···

       38
       38
        
         options.services.homeassistant-satellite = with types; {

     

       39
       39
        
           enable = mkEnableOption (mdDoc "Home Assistant Satellite");

     

       40
       40
        
       

     

       41
       41
       -
           package = mkPackageOptionMD pkgs "homeassistant-satellite" { };

     

       41
       41
       +
           package = mkPackageOption pkgs "homeassistant-satellite" { };

     

       42
       42
        
       

     

       43
       43
        
           user = mkOption {

     

       44
       44
        
             type = str;

+1 -1

nixos/modules/services/home-automation/zwave-js.nix

···

       10
       10
        
         options.services.zwave-js = {

     

       11
       11
        
           enable = mkEnableOption (mdDoc "the zwave-js server on boot");

     

       12
       12
        
       

     

       13
       13
       -
           package = mkPackageOptionMD pkgs "zwave-js-server" { };

     

       13
       13
       +
           package = mkPackageOption pkgs "zwave-js-server" { };

     

       14
       14
        
       

     

       15
       15
        
           port = mkOption {

     

       16
       16
        
             type = types.port;

+1 -1

nixos/modules/services/logging/vector.nix

···

       8
       8
        
         options.services.vector = {

     

       9
       9
        
           enable = mkEnableOption (lib.mdDoc "Vector");

     

       10
       10
        
       

     

       11
       11
       -
           package = mkPackageOptionMD pkgs "vector" { };

     

       11
       11
       +
           package = mkPackageOption pkgs "vector" { };

     

       12
       12
        
       

     

       13
       13
        
           journaldAccess = mkOption {

     

       14
       14
        
             type = types.bool;

+1 -1

nixos/modules/services/mail/listmonk.nix

···

       128
       128
        
                 '';

     

       129
       129
        
               };

     

       130
       130
        
             };

     

       131
       131
       -
             package = mkPackageOptionMD pkgs "listmonk" {};

     

       131
       131
       +
             package = mkPackageOption pkgs "listmonk" {};

     

       132
       132
        
             settings = mkOption {

     

       133
       133
        
               type = types.submodule { freeformType = tomlFormat.type; };

     

       134
       134
        
               description = lib.mdDoc ''

+1 -1

nixos/modules/services/mail/stalwart-mail.nix

···

       11
       11
        
       in {

     

       12
       12
        
         options.services.stalwart-mail = {

     

       13
       13
        
           enable = mkEnableOption (mdDoc "the Stalwart all-in-one email server");

     

       14
       14
       -
           package = mkPackageOptionMD pkgs "stalwart-mail" { };

     

       14
       14
       +
           package = mkPackageOption pkgs "stalwart-mail" { };

     

       15
       15
        
       

     

       16
       16
        
           settings = mkOption {

     

       17
       17
        
             inherit (configFormat) type;

+1 -1

nixos/modules/services/matrix/matrix-sliding-sync.nix

···

       7
       7
        
         options.services.matrix-synapse.sliding-sync = {

     

       8
       8
        
           enable = lib.mkEnableOption (lib.mdDoc "sliding sync");

     

       9
       9
        
       

     

       10
       10
       -
           package = lib.mkPackageOptionMD pkgs "matrix-sliding-sync" { };

     

       10
       10
       +
           package = lib.mkPackageOption pkgs "matrix-sliding-sync" { };

     

       11
       11
        
       

     

       12
       12
        
           settings = lib.mkOption {

     

       13
       13
        
             type = lib.types.submodule {

+1 -1

nixos/modules/services/matrix/maubot.nix

···

       59
       59
        
         options.services.maubot = with lib; {

     

       60
       60
        
           enable = mkEnableOption (mdDoc "maubot");

     

       61
       61
        
       

     

       62
       62
       -
           package = lib.mkPackageOptionMD pkgs "maubot" { };

     

       62
       62
       +
           package = lib.mkPackageOption pkgs "maubot" { };

     

       63
       63
        
       

     

       64
       64
        
           plugins = mkOption {

     

       65
       65
        
             type = types.listOf types.package;

+2 -2

nixos/modules/services/misc/autosuspend.nix

···

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

     

       2
       2
        
       let

     

       3
       3
        
         inherit (lib) mapAttrs' nameValuePair filterAttrs types mkEnableOption

     

       4
       4
       -
           mdDoc mkPackageOptionMD mkOption literalExpression mkIf flatten

     

       4
       4
       +
           mdDoc mkPackageOption mkOption literalExpression mkIf flatten

     

       5
       5
        
           maintainers attrValues;

     

       6
       6
        
       

     

       7
       7
        
         cfg = config.services.autosuspend;

     
···

       96
       96
        
           services.autosuspend = {

     

       97
       97
        
             enable = mkEnableOption (mdDoc "the autosuspend daemon");

     

       98
       98
        
       

     

       99
       99
       -
             package = mkPackageOptionMD pkgs "autosuspend" { };

     

       99
       99
       +
             package = mkPackageOption pkgs "autosuspend" { };

     

       100
       100
        
       

     

       101
       101
        
             settings = mkOption {

     

       102
       102
        
               type = types.submodule {

+1 -1

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

···

       33
       33
        
           services.calibre-server = {

     

       34
       34
        
       

     

       35
       35
        
             enable = mkEnableOption (lib.mdDoc "calibre-server");

     

       36
       36
       -
             package = lib.mkPackageOptionMD pkgs "calibre" { };

     

       36
       36
       +
             package = lib.mkPackageOption pkgs "calibre" { };

     

       37
       37
        
       

     

       38
       38
        
             libraries = mkOption {

     

       39
       39
        
               type = types.listOf types.path;

+1 -1

nixos/modules/services/misc/etcd.nix

···

       15
       15
        
             type = types.bool;

     

       16
       16
        
           };

     

       17
       17
        
       

     

       18
       18
       -
           package = mkPackageOptionMD pkgs "etcd" { };

     

       18
       18
       +
           package = mkPackageOption pkgs "etcd" { };

     

       19
       19
        
       

     

       20
       20
        
           name = mkOption {

     

       21
       21
        
             description = lib.mdDoc "Etcd unique node name.";

+2 -2

nixos/modules/services/misc/forgejo.nix

···

       21
       21
        
           mkIf

     

       22
       22
        
           mkMerge

     

       23
       23
        
           mkOption

     

       24
       24
       -
           mkPackageOptionMD

     

       24
       24
       +
           mkPackageOption

     

       25
       25
        
           mkRemovedOptionModule

     

       26
       26
        
           mkRenamedOptionModule

     

       27
       27
        
           optionalAttrs

     
···

       57
       57
        
           services.forgejo = {

     

       58
       58
        
             enable = mkEnableOption (mdDoc "Forgejo");

     

       59
       59
        
       

     

       60
       60
       -
             package = mkPackageOptionMD pkgs "forgejo" { };

     

       60
       60
       +
             package = mkPackageOption pkgs "forgejo" { };

     

       61
       61
        
       

     

       62
       62
        
             useWizard = mkOption {

     

       63
       63
        
               default = false;

+1 -1

nixos/modules/services/misc/homepage-dashboard.nix

···

       12
       12
        
           services.homepage-dashboard = {

     

       13
       13
        
             enable = lib.mkEnableOption (lib.mdDoc "Homepage Dashboard");

     

       14
       14
        
       

     

       15
       15
       -
             package = lib.mkPackageOptionMD pkgs "homepage-dashboard" { };

     

       15
       15
       +
             package = lib.mkPackageOption pkgs "homepage-dashboard" { };

     

       16
       16
        
       

     

       17
       17
        
             openFirewall = lib.mkOption {

     

       18
       18
        
               type = lib.types.bool;

+1 -1

nixos/modules/services/misc/input-remapper.nix

···

       7
       7
        
         options = {

     

       8
       8
        
           services.input-remapper = {

     

       9
       9
        
             enable = mkEnableOption (lib.mdDoc "input-remapper, an easy to use tool to change the mapping of your input device buttons");

     

       10
       10
       -
             package = mkPackageOptionMD pkgs "input-remapper" { };

     

       10
       10
       +
             package = mkPackageOption pkgs "input-remapper" { };

     

       11
       11
        
             enableUdevRules = mkEnableOption (lib.mdDoc "udev rules added by input-remapper to handle hotplugged devices. Currently disabled by default due to https://github.com/sezanzeb/input-remapper/issues/140");

     

       12
       12
        
             serviceWantedBy = mkOption {

     

       13
       13
        
               default = [ "graphical.target" ];

+1 -1

nixos/modules/services/misc/polaris.nix

···

       13
       13
        
           services.polaris = {

     

       14
       14
        
             enable = mkEnableOption (lib.mdDoc "Polaris Music Server");

     

       15
       15
        
       

     

       16
       16
       -
             package = mkPackageOptionMD pkgs "polaris" { };

     

       16
       16
       +
             package = mkPackageOption pkgs "polaris" { };

     

       17
       17
        
       

     

       18
       18
        
             user = mkOption {

     

       19
       19
        
               type = types.str;

+1 -1

nixos/modules/services/misc/prowlarr.nix

···

       11
       11
        
           services.prowlarr = {

     

       12
       12
        
             enable = mkEnableOption (lib.mdDoc "Prowlarr");

     

       13
       13
        
       

     

       14
       14
       -
             package = mkPackageOptionMD pkgs "prowlarr" { };

     

       14
       14
       +
             package = mkPackageOption pkgs "prowlarr" { };

     

       15
       15
        
       

     

       16
       16
        
             openFirewall = mkOption {

     

       17
       17
        
               type = types.bool;

+1 -1

nixos/modules/services/misc/pufferpanel.nix

···

       33
       33
        
             '';

     

       34
       34
        
           };

     

       35
       35
        
       

     

       36
       36
       -
           package = lib.mkPackageOptionMD pkgs "pufferpanel" { };

     

       36
       36
       +
           package = lib.mkPackageOption pkgs "pufferpanel" { };

     

       37
       37
        
       

     

       38
       38
        
           extraGroups = lib.mkOption {

     

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

+1 -1

nixos/modules/services/misc/rshim.nix

···

       14
       14
        
         options.services.rshim = {

     

       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" { };

     

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

     

       18
       18
        
       

     

       19
       19
        
           backend = lib.mkOption {

     

       20
       20
        
             type = with lib.types; nullOr (enum [ "usb" "pcie" "pcie_lf" ]);

+1 -1

nixos/modules/services/misc/spice-autorandr.nix

···

       7
       7
        
         options = {

     

       8
       8
        
           services.spice-autorandr = {

     

       9
       9
        
             enable = lib.mkEnableOption (lib.mdDoc "spice-autorandr service that will automatically resize display to match SPICE client window size.");

     

       10
       10
       -
             package = lib.mkPackageOptionMD pkgs "spice-autorandr" { };

     

       10
       10
       +
             package = lib.mkPackageOption pkgs "spice-autorandr" { };

     

       11
       11
        
           };

     

       12
       12
        
         };

     

       13
       13

+1 -1

nixos/modules/services/monitoring/certspotter.nix

···

       28
       28
        
         options.services.certspotter = {

     

       29
       29
        
           enable = lib.mkEnableOption "Cert Spotter, a Certificate Transparency log monitor";

     

       30
       30
        
       

     

       31
       31
       -
           package = lib.mkPackageOptionMD pkgs "certspotter" { };

     

       31
       31
       +
           package = lib.mkPackageOption pkgs "certspotter" { };

     

       32
       32
        
       

     

       33
       33
        
           startAtEnd = lib.mkOption {

     

       34
       34
        
             type = lib.types.bool;

+2 -2

nixos/modules/services/monitoring/cockpit.nix

···

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         cfg = config.services.cockpit;

     

       5
       5
       -
         inherit (lib) types mkEnableOption mkOption mkIf mdDoc literalMD mkPackageOptionMD;

     

       5
       5
       +
         inherit (lib) types mkEnableOption mkOption mkIf mdDoc literalMD mkPackageOption;

     

       6
       6
        
         settingsFormat = pkgs.formats.ini {};

     

       7
       7
        
       in {

     

       8
       8
        
         options = {

     

       9
       9
        
           services.cockpit = {

     

       10
       10
        
             enable = mkEnableOption (mdDoc "Cockpit");

     

       11
       11
        
       

     

       12
       12
       -
             package = mkPackageOptionMD pkgs "Cockpit" {

     

       12
       12
       +
             package = mkPackageOption pkgs "Cockpit" {

     

       13
       13
        
               default = [ "cockpit" ];

     

       14
       14
        
             };

     

       15
       15

+1 -1

nixos/modules/services/monitoring/goss.nix

···

       16
       16
        
           services.goss = {

     

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

     

       18
       18
        
       

     

       19
       19
       -
             package = lib.mkPackageOptionMD pkgs "goss" { };

     

       19
       19
       +
             package = lib.mkPackageOption pkgs "goss" { };

     

       20
       20
        
       

     

       21
       21
        
             environment = lib.mkOption {

     

       22
       22
        
               type = lib.types.attrsOf lib.types.str;

+1 -1

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

···

       13
       13
        
         options.services.grafana-agent = {

     

       14
       14
        
           enable = mkEnableOption (lib.mdDoc "grafana-agent");

     

       15
       15
        
       

     

       16
       16
       -
           package = mkPackageOptionMD pkgs "grafana-agent" { };

     

       16
       16
       +
           package = mkPackageOption pkgs "grafana-agent" { };

     

       17
       17
        
       

     

       18
       18
        
           credentials = mkOption {

     

       19
       19
        
             description = lib.mdDoc ''

+1 -1

nixos/modules/services/monitoring/loki.nix

···

       22
       22
        
             '';

     

       23
       23
        
           };

     

       24
       24
        
       

     

       25
       25
       -
           package = lib.mkPackageOptionMD pkgs "grafana-loki" { };

     

       25
       25
       +
           package = lib.mkPackageOption pkgs "grafana-loki" { };

     

       26
       26
        
       

     

       27
       27
        
           group = mkOption {

     

       28
       28
        
             type = types.str;

+1 -1

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

···

       18
       18
        
           services.ocsinventory-agent = {

     

       19
       19
        
             enable = lib.mkEnableOption (lib.mdDoc "OCS Inventory Agent");

     

       20
       20
        
       

     

       21
       21
       -
             package = lib.mkPackageOptionMD pkgs "ocsinventory-agent" { };

     

       21
       21
       +
             package = lib.mkPackageOption pkgs "ocsinventory-agent" { };

     

       22
       22
        
       

     

       23
       23
        
             settings = lib.mkOption {

     

       24
       24
        
               type = lib.types.submodule {

+1 -1

nixos/modules/services/monitoring/prometheus/exporters/exportarr.nix

···

       29
       29
        
             '';

     

       30
       30
        
           };

     

       31
       31
        
       

     

       32
       32
       -
           package = lib.mkPackageOptionMD pkgs "exportarr" { };

     

       32
       32
       +
           package = lib.mkPackageOption pkgs "exportarr" { };

     

       33
       33
        
       

     

       34
       34
        
           environment = lib.mkOption {

     

       35
       35
        
             type = lib.types.attrsOf lib.types.str;

+1 -1

nixos/modules/services/monitoring/prometheus/exporters/php-fpm.nix

···

       10
       10
        
       in {

     

       11
       11
        
         port = 9253;

     

       12
       12
        
         extraOpts = {

     

       13
       13
       -
           package = lib.mkPackageOptionMD pkgs "prometheus-php-fpm-exporter" {};

     

       13
       13
       +
           package = lib.mkPackageOption pkgs "prometheus-php-fpm-exporter" {};

     

       14
       14
        
       

     

       15
       15
        
           telemetryPath = lib.mkOption {

     

       16
       16
        
             type = lib.types.str;

+2 -2

nixos/modules/services/monitoring/thanos.nix

···

       19
       19
        
           mkIf

     

       20
       20
        
           mkMerge

     

       21
       21
        
           mkOption

     

       22
       22
       -
           mkPackageOptionMD

     

       22
       22
       +
           mkPackageOption

     

       23
       23
        
           optional

     

       24
       24
        
           optionalAttrs

     

       25
       25
        
           optionalString

     
···

       682
       682
        
       

     

       683
       683
        
         options.services.thanos = {

     

       684
       684
        
       

     

       685
       685
       -
           package = mkPackageOptionMD pkgs "thanos" {};

     

       685
       685
       +
           package = mkPackageOption pkgs "thanos" {};

     

       686
       686
        
       

     

       687
       687
        
           sidecar = paramsToOptions params.sidecar // {

     

       688
       688
        
             enable = mkEnableOption

+5 -5

nixos/modules/services/network-filesystems/ceph.nix

···

       210
       210
        
                 to the id part in ceph i.e. [ "name1" ] would result in mgr.name1

     

       211
       211
        
               '';

     

       212
       212
        
             };

     

       213
       213
       -
             package = mkPackageOptionMD pkgs "ceph" { };

     

       213
       213
       +
             package = mkPackageOption pkgs "ceph" { };

     

       214
       214
        
             extraConfig = mkOption {

     

       215
       215
        
               type = with types; attrsOf str;

     

       216
       216
        
               default = {};

     
···

       231
       231
        
                 to the id part in ceph i.e. [ "name1" ] would result in mon.name1

     

       232
       232
        
               '';

     

       233
       233
        
             };

     

       234
       234
       -
             package = mkPackageOptionMD pkgs "ceph" { };

     

       234
       234
       +
             package = mkPackageOption pkgs "ceph" { };

     

       235
       235
        
             extraConfig = mkOption {

     

       236
       236
        
               type = with types; attrsOf str;

     

       237
       237
        
               default = {};

     
···

       252
       252
        
                 to the id part in ceph i.e. [ "name1" ] would result in osd.name1

     

       253
       253
        
               '';

     

       254
       254
        
             };

     

       255
       255
       -
             package = mkPackageOptionMD pkgs "ceph" { };

     

       255
       255
       +
             package = mkPackageOption pkgs "ceph" { };

     

       256
       256
        
             extraConfig = mkOption {

     

       257
       257
        
               type = with types; attrsOf str;

     

       258
       258
        
               default = {

     
···

       280
       280
        
                 to the id part in ceph i.e. [ "name1" ] would result in mds.name1

     

       281
       281
        
               '';

     

       282
       282
        
             };

     

       283
       283
       -
             package = mkPackageOptionMD pkgs "ceph" { };

     

       283
       283
       +
             package = mkPackageOption pkgs "ceph" { };

     

       284
       284
        
             extraConfig = mkOption {

     

       285
       285
        
               type = with types; attrsOf str;

     

       286
       286
        
               default = {};

     
···

       292
       292
        
       

     

       293
       293
        
           rgw = {

     

       294
       294
        
             enable = mkEnableOption (lib.mdDoc "Ceph RadosGW daemon");

     

       295
       295
       -
             package = mkPackageOptionMD pkgs "ceph" { };

     

       295
       295
       +
             package = mkPackageOption pkgs "ceph" { };

     

       296
       296
        
             daemons = mkOption {

     

       297
       297
        
               type = with types; listOf str;

     

       298
       298
        
               default = [];

+2 -2

nixos/modules/services/networking/acme-dns.nix

···

       12
       12
        
           mdDoc

     

       13
       13
        
           mkEnableOption

     

       14
       14
        
           mkOption

     

       15
       15
       -
           mkPackageOptionMD

     

       15
       15
       +
           mkPackageOption

     

       16
       16
        
           types

     

       17
       17
        
           ;

     

       18
       18
        
         domain = "acme-dns.example.com";

     
···

       21
       21
        
         options.services.acme-dns = {

     

       22
       22
        
           enable = mkEnableOption (mdDoc "acme-dns");

     

       23
       23
        
       

     

       24
       24
       -
           package = mkPackageOptionMD pkgs "acme-dns" { };

     

       24
       24
       +
           package = mkPackageOption pkgs "acme-dns" { };

     

       25
       25
        
       

     

       26
       26
        
           settings = mkOption {

     

       27
       27
        
             description = mdDoc ''

+1 -1

nixos/modules/services/networking/alice-lg.nix

···

       11
       11
        
           services.alice-lg = {

     

       12
       12
        
             enable = mkEnableOption (lib.mdDoc "Alice Looking Glass");

     

       13
       13
        
       

     

       14
       14
       -
             package = mkPackageOptionMD pkgs "alice-lg" { };

     

       14
       14
       +
             package = mkPackageOption pkgs "alice-lg" { };

     

       15
       15
        
       

     

       16
       16
        
             settings = mkOption {

     

       17
       17
        
               type = settingsFormat.type;

+1 -1

nixos/modules/services/networking/centrifugo.nix

···

       10
       10
        
         options.services.centrifugo = {

     

       11
       11
        
           enable = lib.mkEnableOption (lib.mdDoc "Centrifugo messaging server");

     

       12
       12
        
       

     

       13
       13
       -
           package = lib.mkPackageOptionMD pkgs "centrifugo" { };

     

       13
       13
       +
           package = lib.mkPackageOption pkgs "centrifugo" { };

     

       14
       14
        
       

     

       15
       15
        
           settings = lib.mkOption {

     

       16
       16
        
             type = settingsFormat.type;

+1 -1

nixos/modules/services/networking/cgit.nix

···

       102
       102
        
               options = {

     

       103
       103
        
                 enable = mkEnableOption (mdDoc "cgit");

     

       104
       104
        
       

     

       105
       105
       -
                 package = mkPackageOptionMD pkgs "cgit" {};

     

       105
       105
       +
                 package = mkPackageOption pkgs "cgit" {};

     

       106
       106
        
       

     

       107
       107
        
                 nginx.virtualHost = mkOption {

     

       108
       108
        
                   description = mdDoc "VirtualHost to serve cgit on, defaults to the attribute name.";

+1 -1

nixos/modules/services/networking/dae.nix

···

       16
       16
        
             enable = mkEnableOption

     

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

     

       18
       18
        
       

     

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

     

       19
       19
       +
             package = mkPackageOption pkgs "dae" { };

     

       20
       20
        
       

     

       21
       21
        
       

     

       22
       22
        
             assets = mkOption {

+1 -1

nixos/modules/services/networking/dnsmasq.nix

···

       53
       53
        
               '';

     

       54
       54
        
             };

     

       55
       55
        
       

     

       56
       56
       -
             package = mkPackageOptionMD pkgs "dnsmasq" {};

     

       56
       56
       +
             package = mkPackageOption pkgs "dnsmasq" {};

     

       57
       57
        
       

     

       58
       58
        
             resolveLocalQueries = mkOption {

     

       59
       59
        
               type = types.bool;

+1 -1

nixos/modules/services/networking/envoy.nix

···

       17
       17
        
         options.services.envoy = {

     

       18
       18
        
           enable = mkEnableOption (lib.mdDoc "Envoy reverse proxy");

     

       19
       19
        
       

     

       20
       20
       -
           package = mkPackageOptionMD pkgs "envoy" { };

     

       20
       20
       +
           package = mkPackageOption pkgs "envoy" { };

     

       21
       21
        
       

     

       22
       22
        
           requireValidConfig = mkOption {

     

       23
       23
        
             type = types.bool;

+1 -1

nixos/modules/services/networking/frp.nix

···

       14
       14
        
           services.frp = {

     

       15
       15
        
             enable = mkEnableOption (mdDoc "frp");

     

       16
       16
        
       

     

       17
       17
       -
             package = mkPackageOptionMD pkgs "frp" { };

     

       17
       17
       +
             package = mkPackageOption pkgs "frp" { };

     

       18
       18
        
       

     

       19
       19
        
             role = mkOption {

     

       20
       20
        
               type = types.enum [ "server" "client" ];

+1 -1

nixos/modules/services/networking/haproxy.nix

···

       19
       19
        
       

     

       20
       20
        
             enable = mkEnableOption (lib.mdDoc "HAProxy, the reliable, high performance TCP/HTTP load balancer.");

     

       21
       21
        
       

     

       22
       22
       -
             package = mkPackageOptionMD pkgs "haproxy" { };

     

       22
       22
       +
             package = mkPackageOption pkgs "haproxy" { };

     

       23
       23
        
       

     

       24
       24
        
             user = mkOption {

     

       25
       25
        
               type = types.str;

+1 -1

nixos/modules/services/networking/harmonia.nix

···

       14
       14
        
               description = lib.mdDoc "Path to the signing key that will be used for signing the cache";

     

       15
       15
        
             };

     

       16
       16
        
       

     

       17
       17
       -
             package = lib.mkPackageOptionMD pkgs "harmonia" { };

     

       17
       17
       +
             package = lib.mkPackageOption pkgs "harmonia" { };

     

       18
       18
        
       

     

       19
       19
        
             settings = lib.mkOption {

     

       20
       20
        
               inherit (format) type;

+2 -2

nixos/modules/services/networking/legit.nix

···

       7
       7
        
           mdDoc

     

       8
       8
        
           mkIf

     

       9
       9
        
           mkOption

     

       10
       10
       -
           mkPackageOptionMD

     

       10
       10
       +
           mkPackageOption

     

       11
       11
        
           optionalAttrs

     

       12
       12
        
           optional

     

       13
       13
        
           types;

     
···

       25
       25
        
         options.services.legit = {

     

       26
       26
        
           enable = mkEnableOption (mdDoc "legit git web frontend");

     

       27
       27
        
       

     

       28
       28
       -
           package = mkPackageOptionMD pkgs "legit-web" { };

     

       28
       28
       +
           package = mkPackageOption pkgs "legit-web" { };

     

       29
       29
        
       

     

       30
       30
        
           user = mkOption {

     

       31
       31
        
             type = types.str;

+1 -1

nixos/modules/services/networking/netclient.nix

···

       7
       7
        
       

     

       8
       8
        
         options.services.netclient = {

     

       9
       9
        
           enable = lib.mkEnableOption (lib.mdDoc "Netclient Daemon");

     

       10
       10
       -
           package = lib.mkPackageOptionMD pkgs "netclient" { };

     

       10
       10
       +
           package = lib.mkPackageOption pkgs "netclient" { };

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         config = lib.mkIf cfg.enable {

+1 -1

nixos/modules/services/networking/openconnect.nix

···

       117
       117
        
         };

     

       118
       118
        
       in {

     

       119
       119
        
         options.networking.openconnect = {

     

       120
       120
       -
           package = mkPackageOptionMD pkgs "openconnect" { };

     

       120
       120
       +
           package = mkPackageOption pkgs "openconnect" { };

     

       121
       121
        
       

     

       122
       122
        
           interfaces = mkOption {

     

       123
       123
        
             description = lib.mdDoc "OpenConnect interfaces.";

+1 -1

nixos/modules/services/networking/peroxide.nix

···

       11
       11
        
         options.services.peroxide = {

     

       12
       12
        
           enable = mkEnableOption (lib.mdDoc "peroxide");

     

       13
       13
        
       

     

       14
       14
       -
           package = mkPackageOptionMD pkgs "peroxide" {

     

       14
       14
       +
           package = mkPackageOption pkgs "peroxide" {

     

       15
       15
        
             default = [ "peroxide" ];

     

       16
       16
        
           };

     

       17
       17

+1 -1

nixos/modules/services/networking/shellhub-agent.nix

···

       14
       14
        
       

     

       15
       15
        
             enable = mkEnableOption (lib.mdDoc "ShellHub Agent daemon");

     

       16
       16
        
       

     

       17
       17
       -
             package = mkPackageOptionMD pkgs "shellhub-agent" { };

     

       17
       17
       +
             package = mkPackageOption pkgs "shellhub-agent" { };

     

       18
       18
        
       

     

       19
       19
        
             preferredHostname = mkOption {

     

       20
       20
        
               type = types.str;

+1 -1

nixos/modules/services/networking/sing-box.nix

···

       13
       13
        
           services.sing-box = {

     

       14
       14
        
             enable = lib.mkEnableOption (lib.mdDoc "sing-box universal proxy platform");

     

       15
       15
        
       

     

       16
       16
       -
             package = lib.mkPackageOptionMD pkgs "sing-box" { };

     

       16
       16
       +
             package = lib.mkPackageOption pkgs "sing-box" { };

     

       17
       17
        
       

     

       18
       18
        
             settings = lib.mkOption {

     

       19
       19
        
               type = lib.types.submodule {

+1 -1

nixos/modules/services/networking/tailscale.nix

···

       29
       29
        
             description = lib.mdDoc "Username or user ID of the user allowed to to fetch Tailscale TLS certificates for the node.";

     

       30
       30
        
           };

     

       31
       31
        
       

     

       32
       32
       -
           package = lib.mkPackageOptionMD pkgs "tailscale" {};

     

       32
       32
       +
           package = lib.mkPackageOption pkgs "tailscale" {};

     

       33
       33
        
       

     

       34
       34
        
           openFirewall = mkOption {

     

       35
       35
        
             default = false;

+1 -1

nixos/modules/services/networking/thelounge.nix

···

       25
       25
        
         options.services.thelounge = {

     

       26
       26
        
           enable = mkEnableOption (lib.mdDoc "The Lounge web IRC client");

     

       27
       27
        
       

     

       28
       28
       -
           package = mkPackageOptionMD pkgs "thelounge" { };

     

       28
       28
       +
           package = mkPackageOption pkgs "thelounge" { };

     

       29
       29
        
       

     

       30
       30
        
           public = mkOption {

     

       31
       31
        
             type = types.bool;

+1 -1

nixos/modules/services/networking/tinyproxy.nix

···

       28
       28
        
         options = {

     

       29
       29
        
           services.tinyproxy = {

     

       30
       30
        
             enable = mkEnableOption (lib.mdDoc "Tinyproxy daemon");

     

       31
       31
       -
             package = mkPackageOptionMD pkgs "tinyproxy" {};

     

       31
       31
       +
             package = mkPackageOption pkgs "tinyproxy" {};

     

       32
       32
        
             settings = mkOption {

     

       33
       33
        
               description = lib.mdDoc "Configuration for [tinyproxy](https://tinyproxy.github.io/).";

     

       34
       34
        
               default = { };

+1 -1

nixos/modules/services/networking/twingate.nix

···

       6
       6
        
       {

     

       7
       7
        
         options.services.twingate = {

     

       8
       8
        
           enable = lib.mkEnableOption (lib.mdDoc "Twingate Client daemon");

     

       9
       9
       -
           package = lib.mkPackageOptionMD pkgs "twingate" { };

     

       9
       9
       +
           package = lib.mkPackageOption pkgs "twingate" { };

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         config = lib.mkIf cfg.enable {

+1 -1

nixos/modules/services/networking/vdirsyncer.nix

···

       71
       71
        
           services.vdirsyncer = {

     

       72
       72
        
             enable = mkEnableOption (mdDoc "vdirsyncer");

     

       73
       73
        
       

     

       74
       74
       -
             package = mkPackageOptionMD pkgs "vdirsyncer" {};

     

       74
       74
       +
             package = mkPackageOption pkgs "vdirsyncer" {};

     

       75
       75
        
       

     

       76
       76
        
             jobs = mkOption {

     

       77
       77
        
               description = mdDoc "vdirsyncer job configurations";

+1 -1

nixos/modules/services/networking/webhook.nix

···

       36
       36
        
               which execute configured commands for any person or service that knows the URL

     

       37
       37
        
             '');

     

       38
       38
        
       

     

       39
       39
       -
             package = mkPackageOptionMD pkgs "webhook" {};

     

       39
       39
       +
             package = mkPackageOption pkgs "webhook" {};

     

       40
       40
        
             user = mkOption {

     

       41
       41
        
               type = types.str;

     

       42
       42
        
               default = defaultUser;

+1 -1

nixos/modules/services/networking/wstunnel.nix

···

       48
       48
        
             default = true;

     

       49
       49
        
           };

     

       50
       50
        
       

     

       51
       51
       -
           package = mkPackageOptionMD pkgs "wstunnel" {};

     

       51
       51
       +
           package = mkPackageOption pkgs "wstunnel" {};

     

       52
       52
        
       

     

       53
       53
        
           autoStart = mkOption {

     

       54
       54
        
             description = mdDoc "Whether this tunnel server should be started automatically.";

+1 -1

nixos/modules/services/search/opensearch.nix

···

       25
       25
        
         options.services.opensearch = {

     

       26
       26
        
           enable = mkEnableOption (lib.mdDoc "OpenSearch");

     

       27
       27
        
       

     

       28
       28
       -
           package = lib.mkPackageOptionMD pkgs "OpenSearch" {

     

       28
       28
       +
           package = lib.mkPackageOption pkgs "OpenSearch" {

     

       29
       29
        
             default = [ "opensearch" ];

     

       30
       30
        
           };

     

       31
       31

+1 -1

nixos/modules/services/search/sonic-server.nix

···

       13
       13
        
           services.sonic-server = {

     

       14
       14
        
             enable = lib.mkEnableOption (lib.mdDoc "Sonic Search Index");

     

       15
       15
        
       

     

       16
       16
       -
             package = lib.mkPackageOptionMD pkgs "sonic-server" { };

     

       16
       16
       +
             package = lib.mkPackageOption pkgs "sonic-server" { };

     

       17
       17
        
       

     

       18
       18
        
             settings = lib.mkOption {

     

       19
       19
        
               type = lib.types.submodule { freeformType = settingsFormat.type; };

+1 -1

nixos/modules/services/security/esdm.nix

···

       6
       6
        
       {

     

       7
       7
        
         options.services.esdm = {

     

       8
       8
        
           enable = lib.mkEnableOption (lib.mdDoc "ESDM service configuration");

     

       9
       9
       -
           package = lib.mkPackageOptionMD pkgs "esdm" { };

     

       9
       9
       +
           package = lib.mkPackageOption pkgs "esdm" { };

     

       10
       10
        
           serverEnable = lib.mkOption {

     

       11
       11
        
             type = lib.types.bool;

     

       12
       12
        
             default = true;

+1 -1

nixos/modules/services/security/jitterentropy-rngd.nix

···

       6
       6
        
         options.services.jitterentropy-rngd = {

     

       7
       7
        
           enable =

     

       8
       8
        
             lib.mkEnableOption (lib.mdDoc "jitterentropy-rngd service configuration");

     

       9
       9
       -
           package = lib.mkPackageOptionMD pkgs "jitterentropy-rngd" { };

     

       9
       9
       +
           package = lib.mkPackageOption pkgs "jitterentropy-rngd" { };

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         config = lib.mkIf cfg.enable {

+1 -1

nixos/modules/services/security/kanidm.nix

···

       69
       69
        
           enableServer = lib.mkEnableOption (lib.mdDoc "the Kanidm server");

     

       70
       70
        
           enablePam = lib.mkEnableOption (lib.mdDoc "the Kanidm PAM and NSS integration");

     

       71
       71
        
       

     

       72
       72
       -
           package = lib.mkPackageOptionMD pkgs "kanidm" {};

     

       72
       72
       +
           package = lib.mkPackageOption pkgs "kanidm" {};

     

       73
       73
        
       

     

       74
       74
        
           serverSettings = lib.mkOption {

     

       75
       75
        
             type = lib.types.submodule {

+1 -1

nixos/modules/services/security/vault-agent.nix

···

       14
       14
        
             options = {

     

       15
       15
        
               enable = mkEnableOption (mdDoc "this ${flavour} instance") // { default = true; };

     

       16
       16
        
       

     

       17
       17
       -
               package = mkPackageOptionMD pkgs pkgName { };

     

       17
       17
       +
               package = mkPackageOption pkgs pkgName { };

     

       18
       18
        
       

     

       19
       19
        
               user = mkOption {

     

       20
       20
        
                 type = types.str;

+1 -1

nixos/modules/services/system/bpftune.nix

···

       11
       11
        
           services.bpftune = {

     

       12
       12
        
             enable = lib.mkEnableOption (lib.mdDoc "bpftune BPF driven auto-tuning");

     

       13
       13
        
       

     

       14
       14
       -
             package = lib.mkPackageOptionMD pkgs "bpftune" { };

     

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

     

       15
       15
        
           };

     

       16
       16
        
         };

     

       17
       17

+1 -1

nixos/modules/services/system/zram-generator.nix

···

       11
       11
        
         options.services.zram-generator = {

     

       12
       12
        
           enable = lib.mkEnableOption (lib.mdDoc "Systemd unit generator for zram devices");

     

       13
       13
        
       

     

       14
       14
       -
           package = lib.mkPackageOptionMD pkgs "zram-generator" { };

     

       14
       14
       +
           package = lib.mkPackageOption pkgs "zram-generator" { };

     

       15
       15
        
       

     

       16
       16
        
           settings = lib.mkOption {

     

       17
       17
        
             type = lib.types.submodule {

+1 -1

nixos/modules/services/torrent/flexget.nix

···

       16
       16
        
           services.flexget = {

     

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

     

       18
       18
        
       

     

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

     

       19
       19
       +
             package = mkPackageOption pkgs "flexget" {};

     

       20
       20
        
       

     

       21
       21
        
             user = mkOption {

     

       22
       22
        
               default = "deluge";

+1 -1

nixos/modules/services/torrent/torrentstream.nix

···

       7
       7
        
       {

     

       8
       8
        
         options.services.torrentstream = {

     

       9
       9
        
           enable = lib.mkEnableOption (lib.mdDoc "TorrentStream daemon");

     

       10
       10
       -
           package = lib.mkPackageOptionMD pkgs "torrentstream" { };

     

       10
       10
       +
           package = lib.mkPackageOption pkgs "torrentstream" { };

     

       11
       11
        
           port = lib.mkOption {

     

       12
       12
        
             type = lib.types.port;

     

       13
       13
        
             default = 5082;

+1 -1

nixos/modules/services/torrent/transmission.nix

···

       174
       174
        
               };

     

       175
       175
        
             };

     

       176
       176
        
       

     

       177
       177
       -
             package = mkPackageOptionMD pkgs "transmission" {};

     

       177
       177
       +
             package = mkPackageOption pkgs "transmission" {};

     

       178
       178
        
       

     

       179
       179
        
             downloadDirPermissions = mkOption {

     

       180
       180
        
               type = with types; nullOr str;

+2 -2

nixos/modules/services/video/go2rtc/default.nix

···

       11
       11
        
           mdDoc

     

       12
       12
        
           mkEnableOption

     

       13
       13
        
           mkOption

     

       14
       14
       -
           mkPackageOptionMD

     

       14
       14
       +
           mkPackageOption

     

       15
       15
        
           types

     

       16
       16
        
           ;

     

       17
       17
        
       

     
···

       28
       28
        
         options.services.go2rtc = with types; {

     

       29
       29
        
           enable = mkEnableOption (mdDoc "go2rtc streaming server");

     

       30
       30
        
       

     

       31
       31
       -
           package = mkPackageOptionMD pkgs "go2rtc" { };

     

       31
       31
       +
           package = mkPackageOption pkgs "go2rtc" { };

     

       32
       32
        
       

     

       33
       33
        
           settings = mkOption {

     

       34
       34
        
             default = {};

+1 -1

nixos/modules/services/video/mediamtx.nix

···

       11
       11
        
           services.mediamtx = {

     

       12
       12
        
             enable = lib.mkEnableOption (lib.mdDoc "MediaMTX");

     

       13
       13
        
       

     

       14
       14
       -
             package = lib.mkPackageOptionMD pkgs "mediamtx" { };

     

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

     

       15
       15
        
       

     

       16
       16
        
             settings = lib.mkOption {

     

       17
       17
        
               description = lib.mdDoc ''

+1 -1

nixos/modules/services/web-apps/anuko-time-tracker.nix

···

       58
       58
        
         options.services.anuko-time-tracker = {

     

       59
       59
        
           enable = lib.mkEnableOption (lib.mdDoc "Anuko Time Tracker");

     

       60
       60
        
       

     

       61
       61
       -
           package = lib.mkPackageOptionMD pkgs "anuko-time-tracker" {};

     

       61
       61
       +
           package = lib.mkPackageOption pkgs "anuko-time-tracker" {};

     

       62
       62
        
       

     

       63
       63
        
           database = {

     

       64
       64
        
             createLocally = lib.mkOption {

+2 -2

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

···

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

     

       2
       2
        
       let

     

       3
       3
       -
         inherit (lib) any boolToString concatStringsSep isBool isString mapAttrsToList mkDefault mkEnableOption mkIf mkMerge mkOption optionalAttrs types mkPackageOptionMD;

     

       3
       3
       +
         inherit (lib) any boolToString concatStringsSep isBool isString mapAttrsToList mkDefault mkEnableOption mkIf mkMerge mkOption optionalAttrs types mkPackageOption;

     

       4
       4
        
       

     

       5
       5
        
         package = cfg.package.override { inherit (cfg) stateDir; };

     

       6
       6
        
       

     
···

       50
       50
        
         options.services.dolibarr = {

     

       51
       51
        
           enable = mkEnableOption (lib.mdDoc "dolibarr");

     

       52
       52
        
       

     

       53
       53
       -
           package = mkPackageOptionMD pkgs "dolibarr" { };

     

       53
       53
       +
           package = mkPackageOption pkgs "dolibarr" { };

     

       54
       54
        
       

     

       55
       55
        
           domain = mkOption {

     

       56
       56
        
             type = types.str;

+1 -1

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

···

       32
       32
        
         options.services.gotosocial = {

     

       33
       33
        
           enable = lib.mkEnableOption (lib.mdDoc "ActivityPub social network server");

     

       34
       34
        
       

     

       35
       35
       -
           package = lib.mkPackageOptionMD pkgs "gotosocial" { };

     

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

     

       36
       36
        
       

     

       37
       37
        
           openFirewall = lib.mkOption {

     

       38
       38
        
             type = lib.types.bool;

+1 -1

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

···

       8
       8
        
         options.services.grocy = {

     

       9
       9
        
           enable = mkEnableOption (lib.mdDoc "grocy");

     

       10
       10
        
       

     

       11
       11
       -
           package = mkPackageOptionMD pkgs "grocy" { };

     

       11
       11
       +
           package = mkPackageOption pkgs "grocy" { };

     

       12
       12
        
       

     

       13
       13
        
           hostName = mkOption {

     

       14
       14
        
             type = types.str;

+1 -1

nixos/modules/services/web-apps/guacamole-client.nix

···

       11
       11
        
         options = {

     

       12
       12
        
           services.guacamole-client = {

     

       13
       13
        
             enable = lib.mkEnableOption (lib.mdDoc "Apache Guacamole Client (Tomcat)");

     

       14
       14
       -
             package = lib.mkPackageOptionMD pkgs "guacamole-client" { };

     

       14
       14
       +
             package = lib.mkPackageOption pkgs "guacamole-client" { };

     

       15
       15
        
       

     

       16
       16
        
             settings = lib.mkOption {

     

       17
       17
        
               type = lib.types.submodule {

+1 -1

nixos/modules/services/web-apps/guacamole-server.nix

···

       10
       10
        
         options = {

     

       11
       11
        
           services.guacamole-server = {

     

       12
       12
        
             enable = lib.mkEnableOption (lib.mdDoc "Apache Guacamole Server (guacd)");

     

       13
       13
       -
             package = lib.mkPackageOptionMD pkgs "guacamole-server" { };

     

       13
       13
       +
             package = lib.mkPackageOption pkgs "guacamole-server" { };

     

       14
       14
        
       

     

       15
       15
        
             extraEnvironment = lib.mkOption {

     

       16
       16
        
               type = lib.types.attrsOf lib.types.str;

+1 -1

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

···

       33
       33
        
         ];

     

       34
       34
        
       

     

       35
       35
        
         options.services.hedgedoc = {

     

       36
       36
       -
           package = lib.mkPackageOptionMD pkgs "hedgedoc" { };

     

       36
       36
       +
           package = lib.mkPackageOption pkgs "hedgedoc" { };

     

       37
       37
        
           enable = lib.mkEnableOption (mdDoc "the HedgeDoc Markdown Editor");

     

       38
       38
        
       

     

       39
       39
        
           settings = mkOption {

+1 -1

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

···

       22
       22
        
         options = {

     

       23
       23
        
           services.honk = {

     

       24
       24
        
             enable = lib.mkEnableOption (lib.mdDoc "the Honk server");

     

       25
       25
       -
             package = lib.mkPackageOptionMD pkgs "honk" { };

     

       25
       25
       +
             package = lib.mkPackageOption pkgs "honk" { };

     

       26
       26
        
       

     

       27
       27
        
             host = lib.mkOption {

     

       28
       28
        
               default = "127.0.0.1";

+1 -1

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

···

       12
       12
        
             description = lib.mdDoc "User account under which Kavita runs.";

     

       13
       13
        
           };

     

       14
       14
        
       

     

       15
       15
       -
           package = lib.mkPackageOptionMD pkgs "kavita" { };

     

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

     

       16
       16
        
       

     

       17
       17
        
           dataDir = lib.mkOption {

     

       18
       18
        
             default = "/var/lib/kavita";

+1 -1

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

···

       9
       9
        
         options.services = {

     

       10
       10
        
           lanraragi = {

     

       11
       11
        
             enable = lib.mkEnableOption (lib.mdDoc "LANraragi");

     

       12
       12
       -
             package = lib.mkPackageOptionMD pkgs "lanraragi" { };

     

       12
       12
       +
             package = lib.mkPackageOption pkgs "lanraragi" { };

     

       13
       13
        
       

     

       14
       14
        
             port = lib.mkOption {

     

       15
       15
        
               type = lib.types.port;

+2 -2

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

···

       17
       17
        
           enable = mkEnableOption (lib.mdDoc "lemmy a federated alternative to reddit in rust");

     

       18
       18
        
       

     

       19
       19
        
           server = {

     

       20
       20
       -
             package = mkPackageOptionMD pkgs "lemmy-server" {};

     

       20
       20
       +
             package = mkPackageOption pkgs "lemmy-server" {};

     

       21
       21
        
           };

     

       22
       22
        
       

     

       23
       23
        
           ui = {

     

       24
       24
       -
             package = mkPackageOptionMD pkgs "lemmy-ui" {};

     

       24
       24
       +
             package = mkPackageOption pkgs "lemmy-ui" {};

     

       25
       25
        
       

     

       26
       26
        
             port = mkOption {

     

       27
       27
        
               type = types.port;

+1 -1

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

···

       71
       71
        
               '';

     

       72
       72
        
             };

     

       73
       73
        
       

     

       74
       74
       -
             package = mkPackageOptionMD pkgs "mobilizon" { };

     

       74
       74
       +
             package = mkPackageOption pkgs "mobilizon" { };

     

       75
       75
        
       

     

       76
       76
        
             settings = mkOption {

     

       77
       77
        
               type =

+1 -1

nixos/modules/services/web-apps/openvscode-server.nix

···

       10
       10
        
           services.openvscode-server = {

     

       11
       11
        
             enable = lib.mkEnableOption (lib.mdDoc "openvscode-server");

     

       12
       12
        
       

     

       13
       13
       -
             package = lib.mkPackageOptionMD pkgs "openvscode-server" { };

     

       13
       13
       +
             package = lib.mkPackageOption pkgs "openvscode-server" { };

     

       14
       14
        
       

     

       15
       15
        
             extraPackages = lib.mkOption {

     

       16
       16
        
               default = [ ];

+1 -1

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

···

       77
       77
        
             '';

     

       78
       78
        
           };

     

       79
       79
        
       

     

       80
       80
       -
           package = lib.mkPackageOptionMD pkgs "photoprism" { };

     

       80
       80
       +
           package = lib.mkPackageOption pkgs "photoprism" { };

     

       81
       81
        
       

     

       82
       82
        
           settings = lib.mkOption {

     

       83
       83
        
             type = lib.types.attrsOf lib.types.str;

+2 -2

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

···

       39
       39
        
         options.services = {

     

       40
       40
        
           pixelfed = {

     

       41
       41
        
             enable = mkEnableOption (lib.mdDoc "a Pixelfed instance");

     

       42
       42
       -
             package = mkPackageOptionMD pkgs "pixelfed" { };

     

       43
       43
       -
             phpPackage = mkPackageOptionMD pkgs "php81" { };

     

       42
       42
       +
             package = mkPackageOption pkgs "pixelfed" { };

     

       43
       43
       +
             phpPackage = mkPackageOption pkgs "php81" { };

     

       44
       44
        
       

     

       45
       45
        
             user = mkOption {

     

       46
       46
        
               type = types.str;

+1 -1

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

···

       9
       9
        
         options.services.plausible = {

     

       10
       10
        
           enable = mkEnableOption (lib.mdDoc "plausible");

     

       11
       11
        
       

     

       12
       12
       -
           package = mkPackageOptionMD pkgs "plausible" { };

     

       12
       12
       +
           package = mkPackageOption pkgs "plausible" { };

     

       13
       13
        
       

     

       14
       14
        
           adminUser = {

     

       15
       15
        
             name = mkOption {

+1 -1

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

···

       8
       8
        
       

     

       9
       9
        
           rotateLogs = mkEnableOption "enable an unit and timer that will rotate logs in /var/slskd/logs";

     

       10
       10
        
       

     

       11
       11
       -
           package = mkPackageOptionMD pkgs "slskd" { };

     

       11
       11
       +
           package = mkPackageOption pkgs "slskd" { };

     

       12
       12
        
       

     

       13
       13
        
           nginx = mkOption {

     

       14
       14
        
             description = lib.mdDoc "options for nginx";

+2 -2

nixos/modules/services/x11/desktop-managers/plasma5.nix

···

       31
       31
        
         inherit (lib)

     

       32
       32
        
           getBin optionalAttrs optionalString literalExpression

     

       33
       33
        
           mkRemovedOptionModule mkRenamedOptionModule

     

       34
       34
       -
           mkDefault mkIf mkMerge mkOption mkPackageOptionMD types;

     

       34
       34
       +
           mkDefault mkIf mkMerge mkOption mkPackageOption types;

     

       35
       35
        
       

     

       36
       36
        
         activationScript = ''

     

       37
       37
        
           ${set_XDG_CONFIG_HOME}

     
···

       108
       108
        
               default = true;

     

       109
       109
        
             };

     

       110
       110
        
       

     

       111
       111
       -
             notoPackage = mkPackageOptionMD pkgs "Noto fonts" {

     

       111
       111
       +
             notoPackage = mkPackageOption pkgs "Noto fonts" {

     

       112
       112
        
               default = [ "noto-fonts" ];

     

       113
       113
        
               example = "noto-fonts-lgc-plus";

     

       114
       114
        
             };

+1 -1

nixos/modules/services/x11/picom.nix

···

       61
       61
        
             '';

     

       62
       62
        
           };

     

       63
       63
        
       

     

       64
       64
       -
           package = mkPackageOptionMD pkgs "picom" { };

     

       64
       64
       +
           package = mkPackageOption pkgs "picom" { };

     

       65
       65
        
       

     

       66
       66
        
           fade = mkOption {

     

       67
       67
        
             type = types.bool;

+1 -1

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

···

       9
       9
        
           services.xserver.windowManager.dk = {

     

       10
       10
        
             enable = lib.mkEnableOption (lib.mdDoc "dk");

     

       11
       11
        
       

     

       12
       12
       -
             package = lib.mkPackageOptionMD pkgs "dk" { };

     

       12
       12
       +
             package = lib.mkPackageOption pkgs "dk" { };

     

       13
       13
        
           };

     

       14
       14
        
         };

     

       15
       15

+2 -2

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

···

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

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         inherit (lib) mdDoc mkEnableOption mkIf mkPackageOptionMD singleton;

     

       4
       4
       +
         inherit (lib) mdDoc mkEnableOption mkIf mkPackageOption singleton;

     

       5
       5
        
         cfg = config.services.xserver.windowManager.katriawm;

     

       6
       6
        
       in

     

       7
       7
        
       {

     
···

       9
       9
        
         options = {

     

       10
       10
        
           services.xserver.windowManager.katriawm = {

     

       11
       11
        
             enable = mkEnableOption (mdDoc "katriawm");

     

       12
       12
       -
             package = mkPackageOptionMD pkgs "katriawm" {};

     

       12
       12
       +
             package = mkPackageOption pkgs "katriawm" {};

     

       13
       13
        
           };

     

       14
       14
        
         };

     

       15
       15

+1 -1

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

···

       11
       11
        
         options.services.xserver.windowManager.qtile = {

     

       12
       12
        
           enable = mkEnableOption (lib.mdDoc "qtile");

     

       13
       13
        
       

     

       14
       14
       -
           package = mkPackageOptionMD pkgs "qtile-unwrapped" { };

     

       14
       14
       +
           package = mkPackageOption pkgs "qtile-unwrapped" { };

     

       15
       15
        
       

     

       16
       16
        
           configFile = mkOption {

     

       17
       17
        
             type = with types; nullOr path;

+2 -2

nixos/modules/virtualisation/incus.nix

···

       17
       17
        
               {command}`incus` command line tool, among others.

     

       18
       18
        
             '');

     

       19
       19
        
       

     

       20
       20
       -
             package = lib.mkPackageOptionMD pkgs "incus" { };

     

       20
       20
       +
             package = lib.mkPackageOption pkgs "incus" { };

     

       21
       21
        
       

     

       22
       22
       -
             lxcPackage = lib.mkPackageOptionMD pkgs "lxc" { };

     

       22
       22
       +
             lxcPackage = lib.mkPackageOption pkgs "lxc" { };

     

       23
       23
        
       

     

       24
       24
        
             preseed = lib.mkOption {

     

       25
       25
        
               type = lib.types.nullOr (

+1 -1

nixos/modules/virtualisation/multipass.nix

···

       22
       22
        
               '';

     

       23
       23
        
             };

     

       24
       24
        
       

     

       25
       25
       -
             package = lib.mkPackageOptionMD pkgs "multipass" { };

     

       25
       25
       +
             package = lib.mkPackageOption pkgs "multipass" { };

     

       26
       26
        
           };

     

       27
       27
        
         };

     

       28
       28

+1 -1

nixos/modules/virtualisation/qemu-vm.nix

···

       899
       899
        
           virtualisation.tpm = {

     

       900
       900
        
             enable = mkEnableOption "a TPM device in the virtual machine with a driver, using swtpm.";

     

       901
       901
        
       

     

       902
       902
       -
             package = mkPackageOptionMD cfg.host.pkgs "swtpm" { };

     

       902
       902
       +
             package = mkPackageOption cfg.host.pkgs "swtpm" { };

     

       903
       903
        
       

     

       904
       904
        
             deviceModel = mkOption {

     

       905
       905
        
               type = types.str;