···

       
35
       
35
       
 
       


     

       
36
       
36
       
 
       
    networking.hostFiles = lib.mkOption {

     

       
37
       
37
       
 
       
      type = types.listOf types.path;

     

       
38
       
38
       
-
       
      defaultText = literalDocBook "Hosts from <option>networking.hosts</option> and <option>networking.extraHosts</option>";

     

       
38
       
38
       
+
       
      defaultText = literalMD "Hosts from {option}`networking.hosts` and {option}`networking.extraHosts`";

     

       
39
       
39
       
 
       
      example = literalExpression ''[ "''${pkgs.my-blocklist-package}/share/my-blocklist/hosts" ]'';

     

       
40
       
40
       
 
       
      description = lib.mdDoc ''

     

       
41
       
41
       
 
       
        Files that should be concatenated together to form {file}`/etc/hosts`.

     

···

       
78
       
78
       
 
       
      defaultPackages = mkOption {

     

       
79
       
79
       
 
       
        type = types.listOf types.package;

     

       
80
       
80
       
 
       
        default = defaultPackages;

     

       
81
       
81
       
-
       
        defaultText = literalDocBook ''

     

       
82
       
82
       
-
       
          these packages, with their <literal>meta.priority</literal> numerically increased

     

       
81
       
81
       
+
       
        defaultText = literalMD ''

     

       
82
       
82
       
+
       
          these packages, with their `meta.priority` numerically increased

     

       
83
       
83
       
 
       
          (thus lowering their installation priority):

     

       
84
       
84
       
-
       
          <programlisting>${defaultPackagesText}</programlisting>

     

       
84
       
84
       
+
       


     

       
85
       
85
       
+
       
              ${defaultPackagesText}

     

       
85
       
86
       
 
       
        '';

     

       
86
       
87
       
 
       
        example = [];

     

       
87
       
88
       
 
       
        description = lib.mdDoc ''

     

···

       
183
       
183
       
 
       
    pruneNames = mkOption {

     

       
184
       
184
       
 
       
      type = listOf str;

     

       
185
       
185
       
 
       
      default = lib.optionals (!isFindutils) [ ".bzr" ".cache" ".git" ".hg" ".svn" ];

     

       
186
       
186
       
-
       
      defaultText = literalDocBook ''

     

       
187
       
187
       
-
       
        <literal>[ ".bzr" ".cache" ".git" ".hg" ".svn" ]</literal>, if

     

       
186
       
186
       
+
       
      defaultText = literalMD ''

     

       
187
       
187
       
+
       
        `[ ".bzr" ".cache" ".git" ".hg" ".svn" ]`, if

     

       
188
       
188
       
 
       
        supported by the locate implementation (i.e. mlocate or plocate).

     

       
189
       
189
       
 
       
      '';

     

       
190
       
190
       
 
       
      description = lib.mdDoc ''

     

···

       
71
       
71
       
 
       
      type = types.nullOr (types.enum pkgs.pinentry.flavors);

     

       
72
       
72
       
 
       
      example = "gnome3";

     

       
73
       
73
       
 
       
      default = defaultPinentryFlavor;

     

       
74
       
74
       
-
       
      defaultText = literalDocBook ''matching the configured desktop environment'';

     

       
74
       
74
       
+
       
      defaultText = literalMD ''matching the configured desktop environment'';

     

       
75
       
75
       
 
       
      description = lib.mdDoc ''

     

       
76
       
76
       
 
       
        Which pinentry interface to use. If not null, the path to the

     

       
77
       
77
       
 
       
        pinentry binary will be passed to gpg-agent via commandline and

     

···

       
128
       
128
       
 
       
          mpdCfg.credentials).passwordFile

     

       
129
       
129
       
 
       
      else

     

       
130
       
130
       
 
       
        null;

     

       
131
       
131
       
-
       
      defaultText = literalDocBook ''

     

       
131
       
131
       
+
       
      defaultText = literalMD ''

     

       
132
       
132
       
 
       
        The first password file with read access configured for MPD when using a local instance,

     

       
133
       
133
       
-
       
        otherwise <literal>null</literal>.

     

       
133
       
133
       
+
       
        otherwise `null`.

     

       
134
       
134
       
 
       
      '';

     

       
135
       
135
       
 
       
      type = types.nullOr types.str;

     

       
136
       
136
       
 
       
      description = lib.mdDoc ''

     

···

       
23
       
23
       
 
       
          take 3 (splitString "." config.services.kubernetes.apiserver.serviceClusterIpRange

     

       
24
       
24
       
 
       
        ))

     

       
25
       
25
       
 
       
      ) + ".254";

     

       
26
       
26
       
-
       
      defaultText = literalDocBook ''

     

       
27
       
27
       
-
       
        The <literal>x.y.z.254</literal> IP of

     

       
28
       
28
       
-
       
        <literal>config.${options.services.kubernetes.apiserver.serviceClusterIpRange}</literal>.

     

       
26
       
26
       
+
       
      defaultText = literalMD ''

     

       
27
       
27
       
+
       
        The `x.y.z.254` IP of

     

       
28
       
28
       
+
       
        `config.${options.services.kubernetes.apiserver.serviceClusterIpRange}`.

     

       
29
       
29
       
 
       
      '';

     

       
30
       
30
       
 
       
      type = types.str;

     

       
31
       
31
       
 
       
    };

     

···

       
40
       
40
       
 
       
      key = mkOption {

     

       
41
       
41
       
 
       
        description = lib.mdDoc "Key of taint.";

     

       
42
       
42
       
 
       
        default = name;

     

       
43
       
43
       
-
       
        defaultText = literalDocBook "Name of this submodule.";

     

       
43
       
43
       
+
       
        defaultText = literalMD "Name of this submodule.";

     

       
44
       
44
       
 
       
        type = str;

     

       
45
       
45
       
 
       
      };

     

       
46
       
46
       
 
       
      value = mkOption {

     

···

       
281
       
281
       
 
       
        type = types.path;

     

       
282
       
282
       
 
       
        internal = true;

     

       
283
       
283
       
 
       
        default = etcSlurm;

     

       
284
       
284
       
-
       
        defaultText = literalDocBook ''

     

       
284
       
284
       
+
       
        defaultText = literalMD ''

     

       
285
       
285
       
 
       
          Directory created from generated config files and

     

       
286
       
286
       
-
       
          <literal>config.${opt.extraConfigPaths}</literal>.

     

       
286
       
286
       
+
       
          `config.${opt.extraConfigPaths}`.

     

       
287
       
287
       
 
       
        '';

     

       
288
       
288
       
 
       
        description = ''

     

       
289
       
289
       
 
       
          Path to directory with slurm config files. This option is set by default from the

     

···

       
94
       
94
       
 
       
        type = types.path;

     

       
95
       
95
       
 
       
        description = lib.mdDoc "Optionally pass master.cfg path. Other options in this configuration will be ignored.";

     

       
96
       
96
       
 
       
        default = defaultMasterCfg;

     

       
97
       
97
       
-
       
        defaultText = literalDocBook ''generated configuration file'';

     

       
97
       
97
       
+
       
        defaultText = literalMD ''generated configuration file'';

     

       
98
       
98
       
 
       
        example = "/etc/nixos/buildbot/master.cfg";

     

       
99
       
99
       
 
       
      };

     

       
100
       
100
       
 
       


     

···

       
168
       
168
       
 
       
      hooksPath = mkOption {

     

       
169
       
169
       
 
       
        type = types.path;

     

       
170
       
170
       
 
       
        default = hooksDir config;

     

       
171
       
171
       
-
       
        defaultText = literalDocBook "generated from <option>services.buildkite-agents.&lt;name&gt;.hooks</option>";

     

       
171
       
171
       
+
       
        defaultText = literalMD "generated from {option}`services.buildkite-agents.<name>.hooks`";

     

       
172
       
172
       
 
       
        description = lib.mdDoc ''

     

       
173
       
173
       
 
       
          Path to the directory storing the hooks.

     

       
174
       
174
       
 
       
          Consider using {option}`services.buildkite-agents.<name>.hooks.<name>`

     

···

       
10
       
10
       
 
       
let

     

       
11
       
11
       
 
       
  inherit (lib)

     

       
12
       
12
       
 
       
    filterAttrs

     

       
13
       
13
       
-
       
    literalDocBook

     

       
13
       
13
       
+
       
    literalMD

     

       
14
       
14
       
 
       
    literalExpression

     

       
15
       
15
       
 
       
    mkIf

     

       
16
       
16
       
 
       
    mkOption

     
···

       
235
       
235
       
 
       
    tomlFile = mkOption {

     

       
236
       
236
       
 
       
      type = types.path;

     

       
237
       
237
       
 
       
      internal = true;

     

       
238
       
238
       
-
       
      defaultText = literalDocBook "generated <literal>hercules-ci-agent.toml</literal>";

     

       
238
       
238
       
+
       
      defaultText = literalMD "generated `hercules-ci-agent.toml`";

     

       
239
       
239
       
 
       
      description = ''

     

       
240
       
240
       
 
       
        The fully assembled config file.

     

       
241
       
241
       
 
       
      '';

     

···

       
71
       
71
       
 
       
      baseq3 = mkOption {

     

       
72
       
72
       
 
       
        type = types.either types.package types.path;

     

       
73
       
73
       
 
       
        default = defaultBaseq3;

     

       
74
       
74
       
-
       
        defaultText = literalDocBook "Manually downloaded Quake 3 installation directory.";

     

       
74
       
74
       
+
       
        defaultText = literalMD "Manually downloaded Quake 3 installation directory.";

     

       
75
       
75
       
 
       
        example = "/var/lib/q3ds";

     

       
76
       
76
       
 
       
        description = lib.mdDoc ''

     

       
77
       
77
       
 
       
          Path to the baseq3 files (pak*.pk3). If this is on the nix store (type = package) all .pk3 files should be saved

     

···

       
47
       
47
       
 
       
        $highlight_bin = "${pkgs.highlight}/bin/highlight";

     

       
48
       
48
       
 
       
        ${cfg.extraConfig}

     

       
49
       
49
       
 
       
      '';

     

       
50
       
50
       
-
       
      defaultText = literalDocBook "generated config file";

     

       
50
       
50
       
+
       
      defaultText = literalMD "generated config file";

     

       
51
       
51
       
 
       
      type = types.path;

     

       
52
       
52
       
 
       
      readOnly = true;

     

       
53
       
53
       
 
       
      internal = true;

     

···

       
401
       
401
       
 
       
      config = mkOption {

     

       
402
       
402
       
 
       
        internal = true;

     

       
403
       
403
       
 
       
        default = pkgs.writeText "rippled.conf" rippledCfg;

     

       
404
       
404
       
-
       
        defaultText = literalDocBook "generated config file";

     

       
404
       
404
       
+
       
        defaultText = literalMD "generated config file";

     

       
405
       
405
       
 
       
      };

     

       
406
       
406
       
 
       
    };

     

       
407
       
407
       
 
       
  };

     

···

       
83
       
83
       
 
       
  mkArgumentsOption = cmd: mkOption {

     

       
84
       
84
       
 
       
    type = types.listOf types.str;

     

       
85
       
85
       
 
       
    default = argumentsOf cmd;

     

       
86
       
86
       
-
       
    defaultText = literalDocBook ''

     

       
87
       
87
       
-
       
      calculated from <literal>config.services.thanos.${cmd}</literal>

     

       
86
       
86
       
+
       
    defaultText = literalMD ''

     

       
87
       
87
       
+
       
      calculated from `config.services.thanos.${cmd}`

     

       
88
       
88
       
 
       
    '';

     

       
89
       
89
       
 
       
    description = lib.mdDoc ''

     

       
90
       
90
       
 
       
      Arguments to the `thanos ${cmd}` command.

     

···

       
56
       
56
       
 
       
        ''}

     

       
57
       
57
       
 
       
        ${pkgs.remarshal}/bin/json2toml < config.json > $out

     

       
58
       
58
       
 
       
      '';

     

       
59
       
59
       
-
       
      defaultText = literalDocBook "TOML file generated from <option>services.dnscrypt-proxy2.settings</option>";

     

       
59
       
59
       
+
       
      defaultText = literalMD "TOML file generated from {option}`services.dnscrypt-proxy2.settings`";

     

       
60
       
60
       
 
       
    };

     

       
61
       
61
       
 
       
  };

     

       
62
       
62
       
 
       


     

···

       
30
       
30
       
 
       
      config = mkOption {

     

       
31
       
31
       
 
       
        description = lib.mdDoc "Verbatim ferm.conf configuration.";

     

       
32
       
32
       
 
       
        default = "";

     

       
33
       
33
       
-
       
        defaultText = literalDocBook "empty firewall, allows any traffic";

     

       
33
       
33
       
+
       
        defaultText = literalMD "empty firewall, allows any traffic";

     

       
34
       
34
       
 
       
        type = types.lines;

     

       
35
       
35
       
 
       
      };

     

       
36
       
36
       
 
       
      package = mkOption {

     

···

       
417
       
417
       
 
       
      checkReversePath = mkOption {

     

       
418
       
418
       
 
       
        type = types.either types.bool (types.enum ["strict" "loose"]);

     

       
419
       
419
       
 
       
        default = kernelHasRPFilter;

     

       
420
       
420
       
-
       
        defaultText = literalDocBook "<literal>true</literal> if supported by the chosen kernel";

     

       
420
       
420
       
+
       
        defaultText = literalMD "`true` if supported by the chosen kernel";

     

       
421
       
421
       
 
       
        example = "loose";

     

       
422
       
422
       
 
       
        description =

     

       
423
       
423
       
 
       
          lib.mdDoc ''

     

···

       
88
       
88
       
 
       
        name = "nftables-rules";

     

       
89
       
89
       
 
       
        text = cfg.ruleset;

     

       
90
       
90
       
 
       
      };

     

       
91
       
91
       
-
       
      defaultText = literalDocBook ''a file with the contents of <option>networking.nftables.ruleset</option>'';

     

       
91
       
91
       
+
       
      defaultText = literalMD ''a file with the contents of {option}`networking.nftables.ruleset`'';

     

       
92
       
92
       
 
       
      description =

     

       
93
       
93
       
 
       
        lib.mdDoc ''

     

       
94
       
94
       
 
       
          The ruleset file to be used with nftables.  Should be in a format that

     

···

       
100
       
100
       
 
       
      confDir = mkOption {

     

       
101
       
101
       
 
       
        type = types.path;

     

       
102
       
102
       
 
       
        default = confDir;

     

       
103
       
103
       
-
       
        defaultText = literalDocBook "generated from configuration";

     

       
103
       
103
       
+
       
        defaultText = literalMD "generated from configuration";

     

       
104
       
104
       
 
       
        description = lib.mdDoc "The location of the config files for xrdp.";

     

       
105
       
105
       
 
       
      };

     

       
106
       
106
       
 
       
    };

     

···

       
100
       
100
       
 
       
      enableACME = lib.mkOption {

     

       
101
       
101
       
 
       
        type = lib.types.bool;

     

       
102
       
102
       
 
       
        default = cfg.sslCertificate == null && cfg.sslCertificateKey == null;

     

       
103
       
103
       
-
       
        defaultText = lib.literalDocBook ''

     

       
104
       
104
       
-
       
          <literal>true</literal>, unless <option>services.discourse.sslCertificate</option>

     

       
105
       
105
       
-
       
          and <option>services.discourse.sslCertificateKey</option> are set.

     

       
103
       
103
       
+
       
        defaultText = lib.literalMD ''

     

       
104
       
104
       
+
       
          `true`, unless {option}`services.discourse.sslCertificate`

     

       
105
       
105
       
+
       
          and {option}`services.discourse.sslCertificateKey` are set.

     

       
106
       
106
       
 
       
        '';

     

       
107
       
107
       
 
       
        description = lib.mdDoc ''

     

       
108
       
108
       
 
       
          Whether an ACME certificate should be used to secure

     

···

       
20
       
20
       
 
       
    mkDefault

     

       
21
       
21
       
 
       
    literalExpression

     

       
22
       
22
       
 
       
    isAttrs

     

       
23
       
23
       
-
       
    literalDocBook

     

       
23
       
23
       
+
       
    literalMD

     

       
24
       
24
       
 
       
    maintainers

     

       
25
       
25
       
 
       
    catAttrs

     

       
26
       
26
       
 
       
    collect

     
···

       
165
       
165
       
 
       
          mkOption {

     

       
166
       
166
       
 
       
            type = port;

     

       
167
       
167
       
 
       
            default = dbPorts.${cfg.database.type};

     

       
168
       
168
       
-
       
            defaultText = literalDocBook "default port of selected database";

     

       
168
       
168
       
+
       
            defaultText = literalMD "default port of selected database";

     

       
169
       
169
       
 
       
            description = lib.mdDoc ''

     

       
170
       
170
       
 
       
              Port of the database to connect to.

     

       
171
       
171
       
 
       
            '';

     

···

       
527
       
527
       
 
       
    occ = mkOption {

     

       
528
       
528
       
 
       
      type = types.package;

     

       
529
       
529
       
 
       
      default = occ;

     

       
530
       
530
       
-
       
      defaultText = literalDocBook "generated script";

     

       
530
       
530
       
+
       
      defaultText = literalMD "generated script";

     

       
531
       
531
       
 
       
      internal = true;

     

       
532
       
532
       
 
       
      description = ''

     

       
533
       
533
       
 
       
        The nextcloud-occ program preconfigured to target this Nextcloud instance.

     

···

       
30
       
30
       
 
       
    collectionCgi = mkOption {

     

       
31
       
31
       
 
       
      type = types.path;

     

       
32
       
32
       
 
       
      default = defaultCollectionCgi;

     

       
33
       
33
       
-
       
      defaultText = literalDocBook ''

     

       
34
       
34
       
-
       
        <literal>config.${options.services.collectd.package}</literal> configured for lighttpd

     

       
33
       
33
       
+
       
      defaultText = literalMD ''

     

       
34
       
34
       
+
       
        `config.${options.services.collectd.package}` configured for lighttpd

     

       
35
       
35
       
 
       
      '';

     

       
36
       
36
       
 
       
      description = lib.mdDoc ''

     

       
37
       
37
       
 
       
        Path to collection.cgi script from (collectd sources)/contrib/collection.cgi

     

···

       
62
       
62
       
 
       
    ipAllow = mkOption {

     

       
63
       
63
       
 
       
      type = types.nullOr yaml.type;

     

       
64
       
64
       
 
       
      default = lib.importJSON ./ip_allow.json;

     

       
65
       
65
       
-
       
      defaultText = literalDocBook "upstream defaults";

     

       
65
       
65
       
+
       
      defaultText = literalMD "upstream defaults";

     

       
66
       
66
       
 
       
      example = literalExpression ''

     

       
67
       
67
       
 
       
        {

     

       
68
       
68
       
 
       
          ip_allow = [{

     
···

       
85
       
85
       
 
       
    logging = mkOption {

     

       
86
       
86
       
 
       
      type = types.nullOr yaml.type;

     

       
87
       
87
       
 
       
      default = lib.importJSON ./logging.json;

     

       
88
       
88
       
-
       
      defaultText = literalDocBook "upstream defaults";

     

       
88
       
88
       
+
       
      defaultText = literalMD "upstream defaults";

     

       
89
       
89
       
 
       
      example = { };

     

       
90
       
90
       
 
       
      description = lib.mdDoc ''

     

       
91
       
91
       
 
       
        Configure logs.

     

···

       
285
       
285
       
 
       
            defaultSessionFromLegacyOptions

     

       
286
       
286
       
 
       
          else

     

       
287
       
287
       
 
       
            null;

     

       
288
       
288
       
-
       
        defaultText = literalDocBook ''

     

       
288
       
288
       
+
       
        defaultText = literalMD ''

     

       
289
       
289
       
 
       
          Taken from display manager settings or window manager settings, if either is set.

     

       
290
       
290
       
 
       
        '';

     

       
291
       
291
       
 
       
        example = "gnome";

     

···

       
143
       
143
       
 
       
      readOnly = true;

     

       
144
       
144
       
 
       
      internal = true;

     

       
145
       
145
       
 
       
      default = systemActivationScript (removeAttrs config.system.activationScripts [ "script" ]) true;

     

       
146
       
146
       
-
       
      defaultText = literalDocBook "generated activation script";

     

       
146
       
146
       
+
       
      defaultText = literalMD "generated activation script";

     

       
147
       
147
       
 
       
    };

     

       
148
       
148
       
 
       


     

       
149
       
149
       
 
       
    system.userActivationScripts = mkOption {

     

···

       
75
       
75
       
 
       


     

       
76
       
76
       
 
       
      themePackages = mkOption {

     

       
77
       
77
       
 
       
        default = lib.optional (cfg.theme == "breeze") nixosBreezePlymouth;

     

       
78
       
78
       
-
       
        defaultText = literalDocBook ''

     

       
78
       
78
       
+
       
        defaultText = literalMD ''

     

       
79
       
79
       
 
       
          A NixOS branded variant of the breeze theme when

     

       
80
       
80
       
-
       
          <literal>config.${opt.theme} == "breeze"</literal>, otherwise

     

       
81
       
81
       
-
       
          <literal>[ ]</literal>.

     

       
80
       
80
       
+
       
          `config.${opt.theme} == "breeze"`, otherwise

     

       
81
       
81
       
+
       
          `[ ]`.

     

       
82
       
82
       
 
       
        '';

     

       
83
       
83
       
 
       
        type = types.listOf types.package;

     

       
84
       
84
       
 
       
        description = lib.mdDoc ''

     

···

       
611
       
611
       
 
       
        then "zstd"

     

       
612
       
612
       
 
       
        else "gzip"

     

       
613
       
613
       
 
       
      );

     

       
614
       
614
       
-
       
      defaultText = literalDocBook "<literal>zstd</literal> if the kernel supports it (5.9+), <literal>gzip</literal> if not";

     

       
614
       
614
       
+
       
      defaultText = literalMD "`zstd` if the kernel supports it (5.9+), `gzip` if not";

     

       
615
       
615
       
 
       
      type = types.either types.str (types.functionTo types.str);

     

       
616
       
616
       
 
       
      description = ''

     

       
617
       
617
       
 
       
        The compressor to use on the initrd image. May be any of:

     

···

       
209
       
209
       
 
       
        readOnly = true;

     

       
210
       
210
       
 
       
        type = types.bool;

     

       
211
       
211
       
 
       
        default = inInitrd || inSystem;

     

       
212
       
212
       
-
       
        defaultText = literalDocBook "<literal>true</literal> if ZFS filesystem support is enabled";

     

       
212
       
212
       
+
       
        defaultText = literalMD "`true` if ZFS filesystem support is enabled";

     

       
213
       
213
       
 
       
        description = lib.mdDoc "True if ZFS filesystem support is enabled";

     

       
214
       
214
       
 
       
      };

     

       
215
       
215
       
 
       


     

···

       
20
       
20
       
 
       
  options.virtualisation.digitalOcean.defaultConfigFile = mkOption {

     

       
21
       
21
       
 
       
    type = types.path;

     

       
22
       
22
       
 
       
    default = defaultConfigFile;

     

       
23
       
23
       
-
       
    defaultText = literalDocBook ''

     

       
23
       
23
       
+
       
    defaultText = literalMD ''

     

       
24
       
24
       
 
       
      The default configuration imports user-data if applicable and

     

       
25
       
25
       
 
       
      `(modulesPath + "/virtualisation/digital-ocean-config.nix")`.

     

       
26
       
26
       
 
       
    '';