···

       
27
       
 
       
        '';

     

       
28
       
 
       
      };

     

       
29
       
 
       


     

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

     

       
31
       
 
       
        default = [ "_1password-gui" ];

     

       
32
       
 
       
      };

     

       
33
       
 
       
    };

     

···

       
27
       
 
       
        '';

     

       
28
       
 
       
      };

     

       
29
       
 
       


     

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

     

       
31
       
 
       
        default = [ "_1password-gui" ];

     

       
32
       
 
       
      };

     

       
33
       
 
       
    };

     

···

       
18
       
 
       
    programs._1password = {

     

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

     

       
20
       
 
       


     

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

     

       
22
       
 
       
        default = [ "_1password" ];

     

       
23
       
 
       
      };

     

       
24
       
 
       
    };

     

···

       
18
       
 
       
    programs._1password = {

     

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

     

       
20
       
 
       


     

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

     

       
22
       
 
       
        default = [ "_1password" ];

     

       
23
       
 
       
      };

     

       
24
       
 
       
    };

     

···

       
6
       
 
       
  options = {

     

       
7
       
 
       
    programs.darling = {

     

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

     

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

     

       
10
       
 
       
    };

     

       
11
       
 
       
  };

     

       
12
       
 
       


     

···

       
6
       
 
       
  options = {

     

       
7
       
 
       
    programs.darling = {

     

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

     

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

     

       
10
       
 
       
    };

     

       
11
       
 
       
  };

     

       
12
       
 
       


     

···

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

     

       
15
       
 
       
    '');

     

       
16
       
 
       


     

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

     

       
18
       
 
       


     

       
19
       
 
       
    direnvrcExtra = lib.mkOption {

     

       
20
       
 
       
      type = lib.types.lines;

     
···

       
49
       
 
       
          default = true;

     

       
50
       
 
       
        };

     

       
51
       
 
       


     

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

     

       
53
       
 
       
    };

     

       
54
       
 
       
  };

     

       
55
       
 
       


     

···

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

     

       
15
       
 
       
    '');

     

       
16
       
 
       


     

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

     

       
18
       
 
       


     

       
19
       
 
       
    direnvrcExtra = lib.mkOption {

     

       
20
       
 
       
      type = lib.types.lines;

     
···

       
49
       
 
       
          default = true;

     

       
50
       
 
       
        };

     

       
51
       
 
       


     

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

     

       
53
       
 
       
    };

     

       
54
       
 
       
  };

     

       
55
       
 
       


     

···

       
16
       
 
       
        group.

     

       
17
       
 
       
      '';

     

       
18
       
 
       
    };

     

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

     

       
20
       
 
       
  };

     

       
21
       
 
       


     

       
22
       
 
       
  config = mkIf cfg.enable {

     

···

       
16
       
 
       
        group.

     

       
17
       
 
       
      '';

     

       
18
       
 
       
    };

     

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

     

       
20
       
 
       
  };

     

       
21
       
 
       


     

       
22
       
 
       
  config = mkIf cfg.enable {

     

···

       
23
       
 
       
      '';

     

       
24
       
 
       
    };

     

       
25
       
 
       


     

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

     

       
27
       
 
       


     

       
28
       
 
       
    finalPackage = mkOption {

     

       
29
       
 
       
      type = types.package;

     
···

       
39
       
 
       
      '';

     

       
40
       
 
       
    };

     

       
41
       
 
       


     

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

     

       
43
       
 
       


     

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

     

       
45
       
 
       


     

···

       
23
       
 
       
      '';

     

       
24
       
 
       
    };

     

       
25
       
 
       


     

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

     

       
27
       
 
       


     

       
28
       
 
       
    finalPackage = mkOption {

     

       
29
       
 
       
      type = types.package;

     
···

       
39
       
 
       
      '';

     

       
40
       
 
       
    };

     

       
41
       
 
       


     

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

     

       
43
       
 
       


     

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

     

       
45
       
 
       


     

···

       
2
       
 
       


     

       
3
       
 
       
let

     

       
4
       
 
       
  cfg = config.programs.iay;

     

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

     

       
6
       
 
       
in {

     

       
7
       
 
       
  options.programs.iay = {

     

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

     

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

     

       
10
       
 
       


     

       
11
       
 
       
    minimalPrompt = mkOption {

     

       
12
       
 
       
      type = types.bool;

     

···

       
2
       
 
       


     

       
3
       
 
       
let

     

       
4
       
 
       
  cfg = config.programs.iay;

     

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

     

       
6
       
 
       
in {

     

       
7
       
 
       
  options.programs.iay = {

     

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

     

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

     

       
10
       
 
       


     

       
11
       
 
       
    minimalPrompt = mkOption {

     

       
12
       
 
       
      type = types.bool;

     

···

       
13
       
 
       
        '';

     

       
14
       
 
       
      };

     

       
15
       
 
       


     

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

     

       
17
       
 
       
    };

     

       
18
       
 
       
  };

     

       
19
       
 
       


     

···

       
13
       
 
       
        '';

     

       
14
       
 
       
      };

     

       
15
       
 
       


     

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

     

       
17
       
 
       
    };

     

       
18
       
 
       
  };

     

       
19
       
 
       


     

···

       
11
       
 
       
        default = true;

     

       
12
       
 
       
      };

     

       
13
       
 
       


     

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

     

       
15
       
 
       


     

       
16
       
 
       
      nanorc = lib.mkOption {

     

       
17
       
 
       
        type = lib.types.lines;

     

···

       
11
       
 
       
        default = true;

     

       
12
       
 
       
      };

     

       
13
       
 
       


     

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

     

       
15
       
 
       


     

       
16
       
 
       
      nanorc = lib.mkOption {

     

       
17
       
 
       
        type = lib.types.lines;

     

···

       
8
       
 
       
  options = {

     

       
9
       
 
       
    programs.nexttrace = {

     

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

     

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

     

       
12
       
 
       
    };

     

       
13
       
 
       
  };

     

       
14
       
 
       


     

···

       
8
       
 
       
  options = {

     

       
9
       
 
       
    programs.nexttrace = {

     

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

     

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

     

       
12
       
 
       
    };

     

       
13
       
 
       
  };

     

       
14
       
 
       


     

···

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

     

       
38
       
 
       
  options.programs.nix-ld = {

     

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

     

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

     

       
41
       
 
       
    libraries = lib.mkOption {

     

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

     

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

     

···

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

     

       
38
       
 
       
  options.programs.nix-ld = {

     

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

     

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

     

       
41
       
 
       
    libraries = lib.mkOption {

     

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

     

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

     

···

       
6
       
 
       
{

     

       
7
       
 
       
  options.programs.projecteur = {

     

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

     

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

     

       
10
       
 
       
  };

     

       
11
       
 
       


     

       
12
       
 
       
  config = lib.mkIf cfg.enable {

     

···

       
6
       
 
       
{

     

       
7
       
 
       
  options.programs.projecteur = {

     

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

     

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

     

       
10
       
 
       
  };

     

       
11
       
 
       


     

       
12
       
 
       
  config = lib.mkIf cfg.enable {

     

···

       
13
       
 
       
  options = {

     

       
14
       
 
       
    programs.qdmr = {

     

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

     

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

     

       
17
       
 
       
    };

     

       
18
       
 
       
  };

     

       
19
       
 
       


     

···

       
13
       
 
       
  options = {

     

       
14
       
 
       
    programs.qdmr = {

     

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

     

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

     

       
17
       
 
       
    };

     

       
18
       
 
       
  };

     

       
19
       
 
       


     

···

       
24
       
 
       
      '';

     

       
25
       
 
       
    };

     

       
26
       
 
       


     

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

     

       
28
       
 
       


     

       
29
       
 
       
    settings = lib.mkOption {

     

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

     

···

       
24
       
 
       
      '';

     

       
25
       
 
       
    };

     

       
26
       
 
       


     

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

     

       
28
       
 
       


     

       
29
       
 
       
    settings = lib.mkOption {

     

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

     

···

       
7
       
 
       
{

     

       
8
       
 
       
  options = with types; {

     

       
9
       
 
       
    security.loginDefs = {

     

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

     

       
11
       
 
       


     

       
12
       
 
       
      chfnRestrict = mkOption {

     

       
13
       
 
       
        description = mdDoc ''

     

···

       
7
       
 
       
{

     

       
8
       
 
       
  options = with types; {

     

       
9
       
 
       
    security.loginDefs = {

     

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

     

       
11
       
 
       


     

       
12
       
 
       
      chfnRestrict = mkOption {

     

       
13
       
 
       
        description = mdDoc ''

     

···

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

     

       
2
       
 
       
let

     

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

     

       
4
       
 
       
  cfg = config.programs.skim;

     

       
5
       
 
       
in

     

       
6
       
 
       
{

     
···

       
8
       
 
       
    programs.skim = {

     

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

     

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

     

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

     

       
12
       
 
       
    };

     

       
13
       
 
       
  };

     

       
14
       
 
       


     

···

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

     

       
2
       
 
       
let

     

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

     

       
4
       
 
       
  cfg = config.programs.skim;

     

       
5
       
 
       
in

     

       
6
       
 
       
{

     
···

       
8
       
 
       
    programs.skim = {

     

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

     

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

     

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

     

       
12
       
 
       
    };

     

       
13
       
 
       
  };

     

       
14
       
 
       


     

···

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

     

       
16
       
 
       
    };

     

       
17
       
 
       


     

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

     

       
19
       
 
       
      default = [ "streamdeck-ui" ];

     

       
20
       
 
       
    };

     

       
21
       
 
       


     

···

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

     

       
16
       
 
       
    };

     

       
17
       
 
       


     

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

     

       
19
       
 
       
      default = [ "streamdeck-ui" ];

     

       
20
       
 
       
    };

     

       
21
       
 
       


     

···

       
9
       
 
       
  options.programs.cardboard = {

     

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

     

       
11
       
 
       


     

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

     

       
13
       
 
       
  };

     

       
14
       
 
       


     

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

     

···

       
9
       
 
       
  options.programs.cardboard = {

     

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

     

       
11
       
 
       


     

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

     

       
13
       
 
       
  };

     

       
14
       
 
       


     

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

     

···

       
8
       
 
       
{

     

       
9
       
 
       
  options.programs.waybar = {

     

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

     

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

     

       
12
       
 
       
  };

     

       
13
       
 
       


     

       
14
       
 
       
  config = mkIf cfg.enable {

     

···

       
8
       
 
       
{

     

       
9
       
 
       
  options.programs.waybar = {

     

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

     

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

     

       
12
       
 
       
  };

     

       
13
       
 
       


     

       
14
       
 
       
  config = mkIf cfg.enable {

     

···

       
8
       
 
       
  options.programs.wayfire = {

     

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

     

       
10
       
 
       


     

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

     

       
12
       
 
       


     

       
13
       
 
       
    plugins = lib.mkOption {

     

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

     

···

       
8
       
 
       
  options.programs.wayfire = {

     

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

     

       
10
       
 
       


     

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

     

       
12
       
 
       


     

       
13
       
 
       
    plugins = lib.mkOption {

     

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

     

···

       
11
       
 
       
  options.programs.yazi = {

     

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

     

       
13
       
 
       


     

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

     

       
15
       
 
       


     

       
16
       
 
       
    settings = lib.mkOption {

     

       
17
       
 
       
      type = with lib.types; submodule {

     

···

       
11
       
 
       
  options.programs.yazi = {

     

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

     

       
13
       
 
       


     

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

     

       
15
       
 
       


     

       
16
       
 
       
    settings = lib.mkOption {

     

       
17
       
 
       
      type = with lib.types; submodule {

     

···

       
41
       
 
       
      '';

     

       
42
       
 
       
    };

     

       
43
       
 
       


     

       
44
       
-
       
    package = mkPackageOptionMD pkgs "gmediarender" {

     

       
45
       
 
       
      default = "gmrender-resurrect";

     

       
46
       
 
       
    };

     

       
47
       
 
       


     

···

       
41
       
 
       
      '';

     

       
42
       
 
       
    };

     

       
43
       
 
       


     

       
44
       
+
       
    package = mkPackageOption pkgs "gmediarender" {

     

       
45
       
 
       
      default = "gmrender-resurrect";

     

       
46
       
 
       
    };

     

       
47
       
 
       


     

···

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

     

       
17
       
 
       
        '';

     

       
18
       
 
       
      };

     

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

     

       
20
       
 
       
      autoStart.xdg = mkOption {

     

       
21
       
 
       
        default = true;

     

       
22
       
 
       
        type = with types; bool;

     

···

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

     

       
17
       
 
       
        '';

     

       
18
       
 
       
      };

     

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

     

       
20
       
 
       
      autoStart.xdg = mkOption {

     

       
21
       
 
       
        default = true;

     

       
22
       
 
       
        type = with types; bool;

     

···

       
11
       
 
       


     

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

     

       
13
       
 
       


     

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

     

       
15
       
 
       


     

       
16
       
 
       
      settings = mkOption rec {

     

       
17
       
 
       
        type = settingsFormat.type;

     

···

       
11
       
 
       


     

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

     

       
13
       
 
       


     

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

     

       
15
       
 
       


     

       
16
       
 
       
      settings = mkOption rec {

     

       
17
       
 
       
        type = settingsFormat.type;

     

···

       
12
       
 
       
    mkOption

     

       
13
       
 
       
    mdDoc

     

       
14
       
 
       
    mkEnableOption

     

       
15
       
-
       
    mkPackageOptionMD

     

       
16
       
 
       
    types

     

       
17
       
 
       
    ;

     

       
18
       
 
       


     
···

       
24
       
 
       


     

       
25
       
 
       
{

     

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

     

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

     

       
28
       
 
       


     

       
29
       
 
       
    servers = mkOption {

     

       
30
       
 
       
      default = {};

     

···

       
12
       
 
       
    mkOption

     

       
13
       
 
       
    mdDoc

     

       
14
       
 
       
    mkEnableOption

     

       
15
       
+
       
    mkPackageOption

     

       
16
       
 
       
    types

     

       
17
       
 
       
    ;

     

       
18
       
 
       


     
···

       
24
       
 
       


     

       
25
       
 
       
{

     

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

     

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

     

       
28
       
 
       


     

       
29
       
 
       
    servers = mkOption {

     

       
30
       
 
       
      default = {};

     

···

       
15
       
 
       
    mdDoc

     

       
16
       
 
       
    mkEnableOption

     

       
17
       
 
       
    mkIf

     

       
18
       
-
       
    mkPackageOptionMD

     

       
19
       
 
       
    mkRemovedOptionModule

     

       
20
       
 
       
    types

     

       
21
       
 
       
    ;

     
···

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

     

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

     

       
38
       
 
       


     

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

     

       
40
       
 
       


     

       
41
       
 
       
    uri = mkOption {

     

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

     

···

       
15
       
 
       
    mdDoc

     

       
16
       
 
       
    mkEnableOption

     

       
17
       
 
       
    mkIf

     

       
18
       
+
       
    mkPackageOption

     

       
19
       
 
       
    mkRemovedOptionModule

     

       
20
       
 
       
    types

     

       
21
       
 
       
    ;

     
···

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

     

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

     

       
38
       
 
       


     

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

     

       
40
       
 
       


     

       
41
       
 
       
    uri = mkOption {

     

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

     

···

       
12
       
 
       
    mkOption

     

       
13
       
 
       
    mdDoc

     

       
14
       
 
       
    mkEnableOption

     

       
15
       
-
       
    mkPackageOptionMD

     

       
16
       
 
       
    types

     

       
17
       
 
       
    ;

     

       
18
       
 
       


     
···

       
26
       
 
       
  meta.buildDocsInSandbox = false;

     

       
27
       
 
       


     

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

     

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

     

       
30
       
 
       


     

       
31
       
 
       
    servers = mkOption {

     

       
32
       
 
       
      default = {};

     
···

       
38
       
 
       
          options = {

     

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

     

       
40
       
 
       


     

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

     

       
42
       
 
       


     

       
43
       
 
       
            voice = mkOption {

     

       
44
       
 
       
              type = str;

     

···

       
12
       
 
       
    mkOption

     

       
13
       
 
       
    mdDoc

     

       
14
       
 
       
    mkEnableOption

     

       
15
       
+
       
    mkPackageOption

     

       
16
       
 
       
    types

     

       
17
       
 
       
    ;

     

       
18
       
 
       


     
···

       
26
       
 
       
  meta.buildDocsInSandbox = false;

     

       
27
       
 
       


     

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

     

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

     

       
30
       
 
       


     

       
31
       
 
       
    servers = mkOption {

     

       
32
       
 
       
      default = {};

     
···

       
38
       
 
       
          options = {

     

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

     

       
40
       
 
       


     

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

     

       
42
       
 
       


     

       
43
       
 
       
            voice = mkOption {

     

       
44
       
 
       
              type = str;

     

···

       
231
       
 
       


     

       
232
       
 
       
  ###### interface

     

       
233
       
 
       


     

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

     

       
235
       
 
       


     

       
236
       
 
       
  options.services.borgbackup.jobs = mkOption {

     

       
237
       
 
       
    description = lib.mdDoc ''

     

···

       
231
       
 
       


     

       
232
       
 
       
  ###### interface

     

       
233
       
 
       


     

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

     

       
235
       
 
       


     

       
236
       
 
       
  options.services.borgbackup.jobs = mkOption {

     

       
237
       
 
       
    description = lib.mdDoc ''

     

···

       
10
       
 
       
    services.duplicati = {

     

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

     

       
12
       
 
       


     

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

     

       
14
       
 
       


     

       
15
       
 
       
      port = mkOption {

     

       
16
       
 
       
        default = 8200;

     

···

       
10
       
 
       
    services.duplicati = {

     

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

     

       
12
       
 
       


     

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

     

       
14
       
 
       


     

       
15
       
 
       
      port = mkOption {

     

       
16
       
 
       
        default = 8200;

     

···

       
114
       
 
       
  options.services.sanoid = {

     

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

     

       
116
       
 
       


     

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

     

       
118
       
 
       


     

       
119
       
 
       
    interval = mkOption {

     

       
120
       
 
       
      type = types.str;

     

···

       
114
       
 
       
  options.services.sanoid = {

     

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

     

       
116
       
 
       


     

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

     

       
118
       
 
       


     

       
119
       
 
       
    interval = mkOption {

     

       
120
       
 
       
      type = types.str;

     

···

       
87
       
 
       
  options.services.syncoid = {

     

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

     

       
89
       
 
       


     

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

     

       
91
       
 
       


     

       
92
       
 
       
    interval = mkOption {

     

       
93
       
 
       
      type = types.str;

     

···

       
87
       
 
       
  options.services.syncoid = {

     

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

     

       
89
       
 
       


     

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

     

       
91
       
 
       


     

       
92
       
 
       
    interval = mkOption {

     

       
93
       
 
       
      type = types.str;

     

···

       
13
       
 
       
    services.erigon = {

     

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

     

       
15
       
 
       


     

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

     

       
17
       
 
       


     

       
18
       
 
       
      extraArgs = mkOption {

     

       
19
       
 
       
        type = types.listOf types.str;

     

···

       
13
       
 
       
    services.erigon = {

     

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

     

       
15
       
 
       


     

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

     

       
17
       
 
       


     

       
18
       
 
       
      extraArgs = mkOption {

     

       
19
       
 
       
        type = types.listOf types.str;

     

···

       
19
       
 
       
    mapAttrs'

     

       
20
       
 
       
    mkEnableOption

     

       
21
       
 
       
    mkOption

     

       
22
       
-
       
    mkPackageOptionMD

     

       
23
       
 
       
    mkIf

     

       
24
       
 
       
    nameValuePair

     

       
25
       
 
       
    types

     
···

       
56
       
 
       
  ];

     

       
57
       
 
       


     

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

     

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

     

       
60
       
 
       


     

       
61
       
 
       
    instances = mkOption {

     

       
62
       
 
       
      default = {};

     

···

       
19
       
 
       
    mapAttrs'

     

       
20
       
 
       
    mkEnableOption

     

       
21
       
 
       
    mkOption

     

       
22
       
+
       
    mkPackageOption

     

       
23
       
 
       
    mkIf

     

       
24
       
 
       
    nameValuePair

     

       
25
       
 
       
    types

     
···

       
56
       
 
       
  ];

     

       
57
       
 
       


     

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

     

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

     

       
60
       
 
       


     

       
61
       
 
       
    instances = mkOption {

     

       
62
       
 
       
      default = {};

     

···

       
11
       
 
       
    options = {

     

       
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
       
 
       


     

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

     

       
15
       
 
       


     

       
16
       
 
       
      environment = lib.mkOption {

     

       
17
       
 
       
        default = { };

     

···

       
11
       
 
       
    options = {

     

       
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
       
 
       


     

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

     

       
15
       
 
       


     

       
16
       
 
       
      environment = lib.mkOption {

     

       
17
       
 
       
        default = { };

     

···

       
14
       
 
       
  options = {

     

       
15
       
 
       
    services.woodpecker-server = {

     

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

     

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

     

       
18
       
 
       
      environment = lib.mkOption {

     

       
19
       
 
       
        default = { };

     

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

     

···

       
14
       
 
       
  options = {

     

       
15
       
 
       
    services.woodpecker-server = {

     

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

     

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

     

       
18
       
 
       
      environment = lib.mkOption {

     

       
19
       
 
       
        default = { };

     

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

     

···

       
55
       
 
       
    services.dgraph = {

     

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

     

       
57
       
 
       


     

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

     

       
59
       
 
       


     

       
60
       
 
       
      settings = mkOption {

     

       
61
       
 
       
        type = settingsFormat.type;

     

···

       
55
       
 
       
    services.dgraph = {

     

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

     

       
57
       
 
       


     

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

     

       
59
       
 
       


     

       
60
       
 
       
      settings = mkOption {

     

       
61
       
 
       
        type = settingsFormat.type;

     

···

       
8
       
 
       
  options.services.lldap = with lib; {

     

       
9
       
 
       
    enable = mkEnableOption (mdDoc "lldap");

     

       
10
       
 
       


     

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

     

       
12
       
 
       


     

       
13
       
 
       
    environment = mkOption {

     

       
14
       
 
       
      type = with types; attrsOf str;

     

···

       
8
       
 
       
  options.services.lldap = with lib; {

     

       
9
       
 
       
    enable = mkEnableOption (mdDoc "lldap");

     

       
10
       
 
       


     

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

     

       
12
       
 
       


     

       
13
       
 
       
    environment = mkOption {

     

       
14
       
 
       
      type = with types; attrsOf str;

     

···

       
8
       
 
       
  options = {

     

       
9
       
 
       
    services.openarena = {

     

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

     

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

     

       
12
       
 
       


     

       
13
       
 
       
      openPorts = mkOption {

     

       
14
       
 
       
        type = types.bool;

     

···

       
8
       
 
       
  options = {

     

       
9
       
 
       
    services.openarena = {

     

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

     

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

     

       
12
       
 
       


     

       
13
       
 
       
      openPorts = mkOption {

     

       
14
       
 
       
        type = types.bool;

     

···

       
41
       
 
       
  options = {

     

       
42
       
 
       
    services.quake3-server = {

     

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

     

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

     

       
45
       
 
       


     

       
46
       
 
       
      port = mkOption {

     

       
47
       
 
       
        type = types.port;

     

···

       
41
       
 
       
  options = {

     

       
42
       
 
       
    services.quake3-server = {

     

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

     

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

     

       
45
       
 
       


     

       
46
       
 
       
      port = mkOption {

     

       
47
       
 
       
        type = types.port;

     

···

       
14
       
 
       
    mdDoc

     

       
15
       
 
       
    mkEnableOption

     

       
16
       
 
       
    mkIf

     

       
17
       
-
       
    mkPackageOptionMD

     

       
18
       
 
       
    types

     

       
19
       
 
       
    ;

     

       
20
       
 
       


     
···

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

     

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

     

       
40
       
 
       


     

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

     

       
42
       
 
       


     

       
43
       
 
       
    user = mkOption {

     

       
44
       
 
       
      type = str;

     

···

       
14
       
 
       
    mdDoc

     

       
15
       
 
       
    mkEnableOption

     

       
16
       
 
       
    mkIf

     

       
17
       
+
       
    mkPackageOption

     

       
18
       
 
       
    types

     

       
19
       
 
       
    ;

     

       
20
       
 
       


     
···

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

     

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

     

       
40
       
 
       


     

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

     

       
42
       
 
       


     

       
43
       
 
       
    user = mkOption {

     

       
44
       
 
       
      type = str;

     

···

       
10
       
 
       
  options.services.zwave-js = {

     

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

     

       
12
       
 
       


     

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

     

       
14
       
 
       


     

       
15
       
 
       
    port = mkOption {

     

       
16
       
 
       
      type = types.port;

     

···

       
10
       
 
       
  options.services.zwave-js = {

     

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

     

       
12
       
 
       


     

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

     

       
14
       
 
       


     

       
15
       
 
       
    port = mkOption {

     

       
16
       
 
       
      type = types.port;

     

···

       
8
       
 
       
  options.services.vector = {

     

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

     

       
10
       
 
       


     

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

     

       
12
       
 
       


     

       
13
       
 
       
    journaldAccess = mkOption {

     

       
14
       
 
       
      type = types.bool;

     

···

       
8
       
 
       
  options.services.vector = {

     

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

     

       
10
       
 
       


     

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

     

       
12
       
 
       


     

       
13
       
 
       
    journaldAccess = mkOption {

     

       
14
       
 
       
      type = types.bool;

     

···

       
128
       
 
       
          '';

     

       
129
       
 
       
        };

     

       
130
       
 
       
      };

     

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

     

       
132
       
 
       
      settings = mkOption {

     

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

     

       
134
       
 
       
        description = lib.mdDoc ''

     

···

       
128
       
 
       
          '';

     

       
129
       
 
       
        };

     

       
130
       
 
       
      };

     

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

     

       
132
       
 
       
      settings = mkOption {

     

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

     

       
134
       
 
       
        description = lib.mdDoc ''

     

···

       
11
       
 
       
in {

     

       
12
       
 
       
  options.services.stalwart-mail = {

     

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

     

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

     

       
15
       
 
       


     

       
16
       
 
       
    settings = mkOption {

     

       
17
       
 
       
      inherit (configFormat) type;

     

···

       
11
       
 
       
in {

     

       
12
       
 
       
  options.services.stalwart-mail = {

     

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

     

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

     

       
15
       
 
       


     

       
16
       
 
       
    settings = mkOption {

     

       
17
       
 
       
      inherit (configFormat) type;

     

···

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

     

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

     

       
9
       
 
       


     

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

     

       
11
       
 
       


     

       
12
       
 
       
    settings = lib.mkOption {

     

       
13
       
 
       
      type = lib.types.submodule {

     

···

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

     

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

     

       
9
       
 
       


     

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

     

       
11
       
 
       


     

       
12
       
 
       
    settings = lib.mkOption {

     

       
13
       
 
       
      type = lib.types.submodule {

     

···

       
59
       
 
       
  options.services.maubot = with lib; {

     

       
60
       
 
       
    enable = mkEnableOption (mdDoc "maubot");

     

       
61
       
 
       


     

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

     

       
63
       
 
       


     

       
64
       
 
       
    plugins = mkOption {

     

       
65
       
 
       
      type = types.listOf types.package;

     

···

       
59
       
 
       
  options.services.maubot = with lib; {

     

       
60
       
 
       
    enable = mkEnableOption (mdDoc "maubot");

     

       
61
       
 
       


     

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

     

       
63
       
 
       


     

       
64
       
 
       
    plugins = mkOption {

     

       
65
       
 
       
      type = types.listOf types.package;

     

···

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

     

       
2
       
 
       
let

     

       
3
       
 
       
  inherit (lib) mapAttrs' nameValuePair filterAttrs types mkEnableOption

     

       
4
       
-
       
    mdDoc mkPackageOptionMD mkOption literalExpression mkIf flatten

     

       
5
       
 
       
    maintainers attrValues;

     

       
6
       
 
       


     

       
7
       
 
       
  cfg = config.services.autosuspend;

     
···

       
96
       
 
       
    services.autosuspend = {

     

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

     

       
98
       
 
       


     

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

     

       
100
       
 
       


     

       
101
       
 
       
      settings = mkOption {

     

       
102
       
 
       
        type = types.submodule {

     

···

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

     

       
2
       
 
       
let

     

       
3
       
 
       
  inherit (lib) mapAttrs' nameValuePair filterAttrs types mkEnableOption

     

       
4
       
+
       
    mdDoc mkPackageOption mkOption literalExpression mkIf flatten

     

       
5
       
 
       
    maintainers attrValues;

     

       
6
       
 
       


     

       
7
       
 
       
  cfg = config.services.autosuspend;

     
···

       
96
       
 
       
    services.autosuspend = {

     

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

     

       
98
       
 
       


     

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

     

       
100
       
 
       


     

       
101
       
 
       
      settings = mkOption {

     

       
102
       
 
       
        type = types.submodule {

     

···

       
33
       
 
       
    services.calibre-server = {

     

       
34
       
 
       


     

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

     

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

     

       
37
       
 
       


     

       
38
       
 
       
      libraries = mkOption {

     

       
39
       
 
       
        type = types.listOf types.path;

     

···

       
33
       
 
       
    services.calibre-server = {

     

       
34
       
 
       


     

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

     

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

     

       
37
       
 
       


     

       
38
       
 
       
      libraries = mkOption {

     

       
39
       
 
       
        type = types.listOf types.path;

     

···

       
15
       
 
       
      type = types.bool;

     

       
16
       
 
       
    };

     

       
17
       
 
       


     

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

     

       
19
       
 
       


     

       
20
       
 
       
    name = mkOption {

     

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

     

···

       
15
       
 
       
      type = types.bool;

     

       
16
       
 
       
    };

     

       
17
       
 
       


     

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

     

       
19
       
 
       


     

       
20
       
 
       
    name = mkOption {

     

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

     

···

       
21
       
 
       
    mkIf

     

       
22
       
 
       
    mkMerge

     

       
23
       
 
       
    mkOption

     

       
24
       
-
       
    mkPackageOptionMD

     

       
25
       
 
       
    mkRemovedOptionModule

     

       
26
       
 
       
    mkRenamedOptionModule

     

       
27
       
 
       
    optionalAttrs

     
···

       
57
       
 
       
    services.forgejo = {

     

       
58
       
 
       
      enable = mkEnableOption (mdDoc "Forgejo");

     

       
59
       
 
       


     

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

     

       
61
       
 
       


     

       
62
       
 
       
      useWizard = mkOption {

     

       
63
       
 
       
        default = false;

     

···

       
21
       
 
       
    mkIf

     

       
22
       
 
       
    mkMerge

     

       
23
       
 
       
    mkOption

     

       
24
       
+
       
    mkPackageOption

     

       
25
       
 
       
    mkRemovedOptionModule

     

       
26
       
 
       
    mkRenamedOptionModule

     

       
27
       
 
       
    optionalAttrs

     
···

       
57
       
 
       
    services.forgejo = {

     

       
58
       
 
       
      enable = mkEnableOption (mdDoc "Forgejo");

     

       
59
       
 
       


     

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

     

       
61
       
 
       


     

       
62
       
 
       
      useWizard = mkOption {

     

       
63
       
 
       
        default = false;

     

···

       
12
       
 
       
    services.homepage-dashboard = {

     

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

     

       
14
       
 
       


     

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

     

       
16
       
 
       


     

       
17
       
 
       
      openFirewall = lib.mkOption {

     

       
18
       
 
       
        type = lib.types.bool;

     

···

       
12
       
 
       
    services.homepage-dashboard = {

     

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

     

       
14
       
 
       


     

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

     

       
16
       
 
       


     

       
17
       
 
       
      openFirewall = lib.mkOption {

     

       
18
       
 
       
        type = lib.types.bool;

     

···

       
7
       
 
       
  options = {

     

       
8
       
 
       
    services.input-remapper = {

     

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

     

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

     

       
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
       
 
       
      serviceWantedBy = mkOption {

     

       
13
       
 
       
        default = [ "graphical.target" ];

     

···

       
7
       
 
       
  options = {

     

       
8
       
 
       
    services.input-remapper = {

     

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

     

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

     

       
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
       
 
       
      serviceWantedBy = mkOption {

     

       
13
       
 
       
        default = [ "graphical.target" ];

     

···

       
13
       
 
       
    services.polaris = {

     

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

     

       
15
       
 
       


     

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

     

       
17
       
 
       


     

       
18
       
 
       
      user = mkOption {

     

       
19
       
 
       
        type = types.str;

     

···

       
13
       
 
       
    services.polaris = {

     

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

     

       
15
       
 
       


     

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

     

       
17
       
 
       


     

       
18
       
 
       
      user = mkOption {

     

       
19
       
 
       
        type = types.str;

     

···

       
11
       
 
       
    services.prowlarr = {

     

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

     

       
13
       
 
       


     

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

     

       
15
       
 
       


     

       
16
       
 
       
      openFirewall = mkOption {

     

       
17
       
 
       
        type = types.bool;

     

···

       
11
       
 
       
    services.prowlarr = {

     

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

     

       
13
       
 
       


     

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

     

       
15
       
 
       


     

       
16
       
 
       
      openFirewall = mkOption {

     

       
17
       
 
       
        type = types.bool;

     

···

       
33
       
 
       
      '';

     

       
34
       
 
       
    };

     

       
35
       
 
       


     

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

     

       
37
       
 
       


     

       
38
       
 
       
    extraGroups = lib.mkOption {

     

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

     

···

       
33
       
 
       
      '';

     

       
34
       
 
       
    };

     

       
35
       
 
       


     

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

     

       
37
       
 
       


     

       
38
       
 
       
    extraGroups = lib.mkOption {

     

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

     

···

       
14
       
 
       
  options.services.rshim = {

     

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

     

       
16
       
 
       


     

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

     

       
18
       
 
       


     

       
19
       
 
       
    backend = lib.mkOption {

     

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

     

···

       
14
       
 
       
  options.services.rshim = {

     

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

     

       
16
       
 
       


     

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

     

       
18
       
 
       


     

       
19
       
 
       
    backend = lib.mkOption {

     

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

     

···

       
7
       
 
       
  options = {

     

       
8
       
 
       
    services.spice-autorandr = {

     

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

     

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

     

       
11
       
 
       
    };

     

       
12
       
 
       
  };

     

       
13
       
 
       


     

···

       
7
       
 
       
  options = {

     

       
8
       
 
       
    services.spice-autorandr = {

     

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

     

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

     

       
11
       
 
       
    };

     

       
12
       
 
       
  };

     

       
13
       
 
       


     

···

       
28
       
 
       
  options.services.certspotter = {

     

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

     

       
30
       
 
       


     

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

     

       
32
       
 
       


     

       
33
       
 
       
    startAtEnd = lib.mkOption {

     

       
34
       
 
       
      type = lib.types.bool;

     

···

       
28
       
 
       
  options.services.certspotter = {

     

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

     

       
30
       
 
       


     

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

     

       
32
       
 
       


     

       
33
       
 
       
    startAtEnd = lib.mkOption {

     

       
34
       
 
       
      type = lib.types.bool;

     

···

       
2
       
 
       


     

       
3
       
 
       
let

     

       
4
       
 
       
  cfg = config.services.cockpit;

     

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

     

       
6
       
 
       
  settingsFormat = pkgs.formats.ini {};

     

       
7
       
 
       
in {

     

       
8
       
 
       
  options = {

     

       
9
       
 
       
    services.cockpit = {

     

       
10
       
 
       
      enable = mkEnableOption (mdDoc "Cockpit");

     

       
11
       
 
       


     

       
12
       
-
       
      package = mkPackageOptionMD pkgs "Cockpit" {

     

       
13
       
 
       
        default = [ "cockpit" ];

     

       
14
       
 
       
      };

     

       
15
       
 
       


     

···

       
2
       
 
       


     

       
3
       
 
       
let

     

       
4
       
 
       
  cfg = config.services.cockpit;

     

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

     

       
6
       
 
       
  settingsFormat = pkgs.formats.ini {};

     

       
7
       
 
       
in {

     

       
8
       
 
       
  options = {

     

       
9
       
 
       
    services.cockpit = {

     

       
10
       
 
       
      enable = mkEnableOption (mdDoc "Cockpit");

     

       
11
       
 
       


     

       
12
       
+
       
      package = mkPackageOption pkgs "Cockpit" {

     

       
13
       
 
       
        default = [ "cockpit" ];

     

       
14
       
 
       
      };

     

       
15
       
 
       


     

···

       
16
       
 
       
    services.goss = {

     

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

     

       
18
       
 
       


     

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

     

       
20
       
 
       


     

       
21
       
 
       
      environment = lib.mkOption {

     

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

     

···

       
16
       
 
       
    services.goss = {

     

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

     

       
18
       
 
       


     

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

     

       
20
       
 
       


     

       
21
       
 
       
      environment = lib.mkOption {

     

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

     

···

       
13
       
 
       
  options.services.grafana-agent = {

     

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

     

       
15
       
 
       


     

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

     

       
17
       
 
       


     

       
18
       
 
       
    credentials = mkOption {

     

       
19
       
 
       
      description = lib.mdDoc ''

     

···

       
13
       
 
       
  options.services.grafana-agent = {

     

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

     

       
15
       
 
       


     

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

     

       
17
       
 
       


     

       
18
       
 
       
    credentials = mkOption {

     

       
19
       
 
       
      description = lib.mdDoc ''

     

···

       
22
       
 
       
      '';

     

       
23
       
 
       
    };

     

       
24
       
 
       


     

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

     

       
26
       
 
       


     

       
27
       
 
       
    group = mkOption {

     

       
28
       
 
       
      type = types.str;

     

···

       
22
       
 
       
      '';

     

       
23
       
 
       
    };

     

       
24
       
 
       


     

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

     

       
26
       
 
       


     

       
27
       
 
       
    group = mkOption {

     

       
28
       
 
       
      type = types.str;

     

···

       
18
       
 
       
    services.ocsinventory-agent = {

     

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

     

       
20
       
 
       


     

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

     

       
22
       
 
       


     

       
23
       
 
       
      settings = lib.mkOption {

     

       
24
       
 
       
        type = lib.types.submodule {

     

···

       
18
       
 
       
    services.ocsinventory-agent = {

     

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

     

       
20
       
 
       


     

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

     

       
22
       
 
       


     

       
23
       
 
       
      settings = lib.mkOption {

     

       
24
       
 
       
        type = lib.types.submodule {

     

···

       
29
       
 
       
      '';

     

       
30
       
 
       
    };

     

       
31
       
 
       


     

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

     

       
33
       
 
       


     

       
34
       
 
       
    environment = lib.mkOption {

     

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

     

···

       
29
       
 
       
      '';

     

       
30
       
 
       
    };

     

       
31
       
 
       


     

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

     

       
33
       
 
       


     

       
34
       
 
       
    environment = lib.mkOption {

     

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

     

···

       
10
       
 
       
in {

     

       
11
       
 
       
  port = 9253;

     

       
12
       
 
       
  extraOpts = {

     

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

     

       
14
       
 
       


     

       
15
       
 
       
    telemetryPath = lib.mkOption {

     

       
16
       
 
       
      type = lib.types.str;

     

···

       
10
       
 
       
in {

     

       
11
       
 
       
  port = 9253;

     

       
12
       
 
       
  extraOpts = {

     

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

     

       
14
       
 
       


     

       
15
       
 
       
    telemetryPath = lib.mkOption {

     

       
16
       
 
       
      type = lib.types.str;

     

···

       
19
       
 
       
    mkIf

     

       
20
       
 
       
    mkMerge

     

       
21
       
 
       
    mkOption

     

       
22
       
-
       
    mkPackageOptionMD

     

       
23
       
 
       
    optional

     

       
24
       
 
       
    optionalAttrs

     

       
25
       
 
       
    optionalString

     
···

       
682
       
 
       


     

       
683
       
 
       
  options.services.thanos = {

     

       
684
       
 
       


     

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

     

       
686
       
 
       


     

       
687
       
 
       
    sidecar = paramsToOptions params.sidecar // {

     

       
688
       
 
       
      enable = mkEnableOption

     

···

       
19
       
 
       
    mkIf

     

       
20
       
 
       
    mkMerge

     

       
21
       
 
       
    mkOption

     

       
22
       
+
       
    mkPackageOption

     

       
23
       
 
       
    optional

     

       
24
       
 
       
    optionalAttrs

     

       
25
       
 
       
    optionalString

     
···

       
682
       
 
       


     

       
683
       
 
       
  options.services.thanos = {

     

       
684
       
 
       


     

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

     

       
686
       
 
       


     

       
687
       
 
       
    sidecar = paramsToOptions params.sidecar // {

     

       
688
       
 
       
      enable = mkEnableOption

     

···

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

     

       
211
       
 
       
        '';

     

       
212
       
 
       
      };

     

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

     

       
214
       
 
       
      extraConfig = mkOption {

     

       
215
       
 
       
        type = with types; attrsOf str;

     

       
216
       
 
       
        default = {};

     
···

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

     

       
232
       
 
       
        '';

     

       
233
       
 
       
      };

     

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

     

       
235
       
 
       
      extraConfig = mkOption {

     

       
236
       
 
       
        type = with types; attrsOf str;

     

       
237
       
 
       
        default = {};

     
···

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

     

       
253
       
 
       
        '';

     

       
254
       
 
       
      };

     

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

     

       
256
       
 
       
      extraConfig = mkOption {

     

       
257
       
 
       
        type = with types; attrsOf str;

     

       
258
       
 
       
        default = {

     
···

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

     

       
281
       
 
       
        '';

     

       
282
       
 
       
      };

     

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

     

       
284
       
 
       
      extraConfig = mkOption {

     

       
285
       
 
       
        type = with types; attrsOf str;

     

       
286
       
 
       
        default = {};

     
···

       
292
       
 
       


     

       
293
       
 
       
    rgw = {

     

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

     

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

     

       
296
       
 
       
      daemons = mkOption {

     

       
297
       
 
       
        type = with types; listOf str;

     

       
298
       
 
       
        default = [];

     

···

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

     

       
211
       
 
       
        '';

     

       
212
       
 
       
      };

     

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

     

       
214
       
 
       
      extraConfig = mkOption {

     

       
215
       
 
       
        type = with types; attrsOf str;

     

       
216
       
 
       
        default = {};

     
···

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

     

       
232
       
 
       
        '';

     

       
233
       
 
       
      };

     

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

     

       
235
       
 
       
      extraConfig = mkOption {

     

       
236
       
 
       
        type = with types; attrsOf str;

     

       
237
       
 
       
        default = {};

     
···

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

     

       
253
       
 
       
        '';

     

       
254
       
 
       
      };

     

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

     

       
256
       
 
       
      extraConfig = mkOption {

     

       
257
       
 
       
        type = with types; attrsOf str;

     

       
258
       
 
       
        default = {

     
···

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

     

       
281
       
 
       
        '';

     

       
282
       
 
       
      };

     

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

     

       
284
       
 
       
      extraConfig = mkOption {

     

       
285
       
 
       
        type = with types; attrsOf str;

     

       
286
       
 
       
        default = {};

     
···

       
292
       
 
       


     

       
293
       
 
       
    rgw = {

     

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

     

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

     

       
296
       
 
       
      daemons = mkOption {

     

       
297
       
 
       
        type = with types; listOf str;

     

       
298
       
 
       
        default = [];

     

···

       
12
       
 
       
    mdDoc

     

       
13
       
 
       
    mkEnableOption

     

       
14
       
 
       
    mkOption

     

       
15
       
-
       
    mkPackageOptionMD

     

       
16
       
 
       
    types

     

       
17
       
 
       
    ;

     

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

     
···

       
21
       
 
       
  options.services.acme-dns = {

     

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

     

       
23
       
 
       


     

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

     

       
25
       
 
       


     

       
26
       
 
       
    settings = mkOption {

     

       
27
       
 
       
      description = mdDoc ''

     

···

       
12
       
 
       
    mdDoc

     

       
13
       
 
       
    mkEnableOption

     

       
14
       
 
       
    mkOption

     

       
15
       
+
       
    mkPackageOption

     

       
16
       
 
       
    types

     

       
17
       
 
       
    ;

     

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

     
···

       
21
       
 
       
  options.services.acme-dns = {

     

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

     

       
23
       
 
       


     

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

     

       
25
       
 
       


     

       
26
       
 
       
    settings = mkOption {

     

       
27
       
 
       
      description = mdDoc ''

     

···

       
11
       
 
       
    services.alice-lg = {

     

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

     

       
13
       
 
       


     

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

     

       
15
       
 
       


     

       
16
       
 
       
      settings = mkOption {

     

       
17
       
 
       
        type = settingsFormat.type;

     

···

       
11
       
 
       
    services.alice-lg = {

     

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

     

       
13
       
 
       


     

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

     

       
15
       
 
       


     

       
16
       
 
       
      settings = mkOption {

     

       
17
       
 
       
        type = settingsFormat.type;

     

···

       
10
       
 
       
  options.services.centrifugo = {

     

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

     

       
12
       
 
       


     

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

     

       
14
       
 
       


     

       
15
       
 
       
    settings = lib.mkOption {

     

       
16
       
 
       
      type = settingsFormat.type;

     

···

       
10
       
 
       
  options.services.centrifugo = {

     

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

     

       
12
       
 
       


     

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

     

       
14
       
 
       


     

       
15
       
 
       
    settings = lib.mkOption {

     

       
16
       
 
       
      type = settingsFormat.type;

     

···

       
102
       
 
       
        options = {

     

       
103
       
 
       
          enable = mkEnableOption (mdDoc "cgit");

     

       
104
       
 
       


     

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

     

       
106
       
 
       


     

       
107
       
 
       
          nginx.virtualHost = mkOption {

     

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

     

···

       
102
       
 
       
        options = {

     

       
103
       
 
       
          enable = mkEnableOption (mdDoc "cgit");

     

       
104
       
 
       


     

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

     

       
106
       
 
       


     

       
107
       
 
       
          nginx.virtualHost = mkOption {

     

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