commit 8e0d18cd9d437634da805cfcfd7a5d07359be3d8 · pyrox.dev/nixpkgs

+17 -2

doc/stdenv/stdenv.chapter.md

···

       871
       871
        
       # adds `FOOBAR=baz` to `$out/bin/foo`’s environment

     

       872
       872
        
       makeWrapper $out/bin/foo $wrapperfile --set FOOBAR baz

     

       873
       873
        
       

     

       874
       874
       -
       # prefixes the binary paths of `hello` and `git`

     

       874
       874
       +
       # Prefixes the binary paths of `hello` and `git`

     

       875
       875
       +
       # and suffixes the binary path of `xdg-utils`.

     

       875
       876
        
       # Be advised that paths often should be patched in directly

     

       876
       877
        
       # (via string replacements or in `configurePhase`).

     

       877
       877
       -
       makeWrapper $out/bin/foo $wrapperfile --prefix PATH : ${lib.makeBinPath [ hello git ]}

     

       878
       878
       +
       makeWrapper $out/bin/foo $wrapperfile \

     

       879
       879
       +
         --prefix PATH : ${lib.makeBinPath [ hello git ]} \

     

       880
       880
       +
         --suffix PATH : ${lib.makeBinPath [ xdg-utils ]}

     

       878
       881
        
       ```

     

       882
       882
       +
       

     

       883
       883
       +
       Packages may expect or require other utilities to be available at runtime.

     

       884
       884
       +
       `makeWrapper` can be used to add packages to a `PATH` environment variable local to a wrapper.

     

       885
       885
       +
       

     

       886
       886
       +
       Use `--prefix` to explicitly set dependencies in `PATH`.

     

       887
       887
       +
       

     

       888
       888
       +
       :::{note}

     

       889
       889
       +
       `--prefix` essentially hard-codes dependencies into the wrapper.

     

       890
       890
       +
       They cannot be overridden without rebuilding the package.

     

       891
       891
       +
       :::

     

       892
       892
       +
       

     

       893
       893
       +
       If dependencies should be resolved at runtime, use `--suffix` to append fallback values to `PATH`.

     

       879
       894
        
       

     

       880
       895
        
       There’s many more kinds of arguments, they are documented in `nixpkgs/pkgs/build-support/setup-hooks/make-wrapper.sh` for the `makeWrapper` implementation and in `nixpkgs/pkgs/build-support/setup-hooks/make-binary-wrapper/make-binary-wrapper.sh` for the `makeBinaryWrapper` implementation.

     

       881
       896

+5 -5

nixos/modules/config/krb5/default.nix

···

       204
       204
        
                   admin_server = SYSLOG:NOTICE

     

       205
       205
        
                   default      = SYSLOG:NOTICE

     

       206
       206
        
               '';

     

       207
       207
       -
               description = ''

     

       208
       208
       -
                 These lines go to the end of <literal>krb5.conf</literal> verbatim.

     

       209
       209
       -
                 <literal>krb5.conf</literal> may include any of the relations that are

     

       210
       210
       -
                 valid for <literal>kdc.conf</literal> (see <literal>man

     

       211
       211
       -
                 kdc.conf</literal>), but it is not a recommended practice.

     

       207
       207
       +
               description = lib.mdDoc ''

     

       208
       208
       +
                 These lines go to the end of `krb5.conf` verbatim.

     

       209
       209
       +
                 `krb5.conf` may include any of the relations that are

     

       210
       210
       +
                 valid for `kdc.conf` (see `man kdc.conf`),

     

       211
       211
       +
                 but it is not a recommended practice.

     

       212
       212
        
               '';

     

       213
       213
        
             };

     

       214
       214

+5 -5

nixos/modules/config/ldap.nix

···

       186
       186
        
               policy = mkOption {

     

       187
       187
        
                 default = "hard_open";

     

       188
       188
        
                 type = types.enum [ "hard_open" "hard_init" "soft" ];

     

       189
       189
       -
                 description = ''

     

       189
       189
       +
                 description = lib.mdDoc ''

     

       190
       190
        
                   Specifies the policy to use for reconnecting to an unavailable

     

       191
       191
       -
                   LDAP server. The default is <literal>hard_open</literal>, which

     

       191
       191
       +
                   LDAP server. The default is `hard_open`, which

     

       192
       192
        
                   reconnects if opening the connection to the directory server

     

       193
       193
       -
                   failed. By contrast, <literal>hard_init</literal> reconnects if

     

       193
       193
       +
                   failed. By contrast, `hard_init` reconnects if

     

       194
       194
        
                   initializing the connection failed. Initializing may not

     

       195
       195
        
                   actually contact the directory server, and it is possible that

     

       196
       196
        
                   a malformed configuration file will trigger reconnection. If

     

       197
       197
       -
                   <literal>soft</literal> is specified, then

     

       198
       198
       -
                   <package>nss_ldap</package> will return immediately on server

     

       197
       197
       +
                   `soft` is specified, then

     

       198
       198
       +
                   `nss_ldap` will return immediately on server

     

       199
       199
        
                   failure. All hard reconnect policies block with exponential

     

       200
       200
        
                   backoff before retrying.

     

       201
       201
        
                 '';

+5 -5

nixos/modules/config/system-path.nix

···

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

     

       85
       85
        
               '';

     

       86
       86
        
               example = [];

     

       87
       87
       -
               description = ''

     

       87
       87
       +
               description = lib.mdDoc ''

     

       88
       88
        
                 Set of default packages that aren't strictly necessary

     

       89
       89
        
                 for a running system, entries can be removed for a more

     

       90
       90
        
                 minimal NixOS installation.

     

       91
       91
        
       

     

       92
       92
       -
                 Note: If <package>pkgs.nano</package> is removed from this list,

     

       92
       92
       +
                 Note: If `pkgs.nano` is removed from this list,

     

       93
       93
        
                 make sure another editor is installed and the

     

       94
       94
       -
                 <literal>EDITOR</literal> environment variable is set to it.

     

       94
       94
       +
                 `EDITOR` environment variable is set to it.

     

       95
       95
        
                 Environment variables can be set using

     

       96
       96
       -
                 <option>environment.variables</option>.

     

       96
       96
       +
                 {option}`environment.variables`.

     

       97
       97
        
       

     

       98
       98
        
                 Like with systemPackages, packages are installed to

     

       99
       99
       -
                 <filename>/run/current-system/sw</filename>. They are

     

       99
       99
       +
                 {file}`/run/current-system/sw`. They are

     

       100
       100
        
                 automatically available to all users, and are

     

       101
       101
        
                 automatically updated every time you rebuild the system

     

       102
       102
        
                 configuration.

+3 -3

nixos/modules/config/xdg/portal.nix

···

       40
       40
        
           extraPortals = mkOption {

     

       41
       41
        
             type = types.listOf types.package;

     

       42
       42
        
             default = [ ];

     

       43
       43
       -
             description = ''

     

       43
       43
       +
             description = lib.mdDoc ''

     

       44
       44
        
               List of additional portals to add to path. Portals allow interaction

     

       45
       45
        
               with system, like choosing files or taking screenshots. At minimum,

     

       46
       46
        
               a desktop portal implementation should be listed. GNOME and KDE already

     

       47
       47
       -
               adds <package>xdg-desktop-portal-gtk</package>; and

     

       48
       48
       -
               <package>xdg-desktop-portal-kde</package> respectively. On other desktop

     

       47
       47
       +
               adds `xdg-desktop-portal-gtk`; and

     

       48
       48
       +
               `xdg-desktop-portal-kde` respectively. On other desktop

     

       49
       49
        
               environments you probably want to add them yourself.

     

       50
       50
        
             '';

     

       51
       51
        
           };

+3 -3

nixos/modules/config/xdg/portals/lxqt.nix

···

       15
       15
        
           enable = mkEnableOption ''

     

       16
       16
        
             the desktop portal for the LXQt desktop environment.

     

       17
       17
        
       

     

       18
       18
       -
             This will add the <package>lxqt.xdg-desktop-portal-lxqt</package>

     

       18
       18
       +
             This will add the <literal>lxqt.xdg-desktop-portal-lxqt</literal>

     

       19
       19
        
             package (with the extra Qt styles) into the

     

       20
       20
        
             <option>xdg.portal.extraPortals</option> option

     

       21
       21
        
           '';

     
···

       29
       29
        
               pkgs.qtcurve

     

       30
       30
        
             ];

     

       31
       31
        
             '';

     

       32
       32
       -
             description = ''

     

       32
       32
       +
             description = lib.mdDoc ''

     

       33
       33
        
               Extra Qt styles that will be available to the

     

       34
       34
       -
               <package>lxqt.xdg-desktop-portal-lxqt</package>.

     

       34
       34
       +
               `lxqt.xdg-desktop-portal-lxqt`.

     

       35
       35
        
             '';

     

       36
       36
        
           };

     

       37
       37
        
         };

+4 -4

nixos/modules/config/xdg/portals/wlr.nix

···

       17
       17
        
           enable = mkEnableOption ''

     

       18
       18
        
             desktop portal for wlroots-based desktops

     

       19
       19
        
       

     

       20
       20
       -
             This will add the <package>xdg-desktop-portal-wlr</package> package into

     

       20
       20
       +
             This will add the <literal>xdg-desktop-portal-wlr</literal> package into

     

       21
       21
        
             the <option>xdg.portal.extraPortals</option> option, and provide the

     

       22
       22
        
             configuration file

     

       23
       23
        
           '';

     

       24
       24
        
       

     

       25
       25
        
           settings = mkOption {

     

       26
       26
       -
             description = ''

     

       27
       27
       -
               Configuration for <package>xdg-desktop-portal-wlr</package>.

     

       26
       26
       +
             description = lib.mdDoc ''

     

       27
       27
       +
               Configuration for `xdg-desktop-portal-wlr`.

     

       28
       28
        
       

     

       29
       29
       -
               See <literal>xdg-desktop-portal-wlr(5)</literal> for supported

     

       29
       29
       +
               See `xdg-desktop-portal-wlr(5)` for supported

     

       30
       30
        
               values.

     

       31
       31
        
             '';

     

       32
       32

+5 -5

nixos/modules/config/zram.nix

···

       103
       103
        
               default = "zstd";

     

       104
       104
        
               example = "lz4";

     

       105
       105
        
               type = with types; either (enum [ "lzo" "lz4" "zstd" ]) str;

     

       106
       106
       -
               description = ''

     

       107
       107
       -
                 Compression algorithm. <literal>lzo</literal> has good compression,

     

       108
       108
       -
                 but is slow. <literal>lz4</literal> has bad compression, but is fast.

     

       109
       109
       -
                 <literal>zstd</literal> is both good compression and fast, but requires newer kernel.

     

       106
       106
       +
               description = lib.mdDoc ''

     

       107
       107
       +
                 Compression algorithm. `lzo` has good compression,

     

       108
       108
       +
                 but is slow. `lz4` has bad compression, but is fast.

     

       109
       109
       +
                 `zstd` is both good compression and fast, but requires newer kernel.

     

       110
       110
        
                 You can check what other algorithms are supported by your zram device with

     

       111
       111
       -
                 <programlisting>cat /sys/class/block/zram*/comp_algorithm</programlisting>

     

       111
       111
       +
                 {command}`cat /sys/class/block/zram*/comp_algorithm`

     

       112
       112
        
               '';

     

       113
       113
        
             };

     

       114
       114
        
           };

+1 -1

nixos/modules/hardware/corectrl.nix

···

       20
       20
        
               type = types.str;

     

       21
       21
        
               default = "0xfffd7fff";

     

       22
       22
        
               example = "0xffffffff";

     

       23
       23
       -
               description = ''

     

       23
       23
       +
               description = lib.mdDoc ''

     

       24
       24
        
                 Sets the `amdgpu.ppfeaturemask` kernel option.

     

       25
       25
        
                 In particular, it is used here to set the overdrive bit.

     

       26
       26
        
                 Default is `0xfffd7fff` as it is less likely to cause flicker issues.

+3 -3

nixos/modules/hardware/cpu/amd-sev.nix

···

       8
       8
        
           options.hardware.cpu.amd.sev = {

     

       9
       9
        
             enable = mkEnableOption "access to the AMD SEV device";

     

       10
       10
        
             user = mkOption {

     

       11
       11
       -
               description = "Owner to assign to the SEV device.";

     

       11
       11
       +
               description = lib.mdDoc "Owner to assign to the SEV device.";

     

       12
       12
        
               type = types.str;

     

       13
       13
        
               default = "root";

     

       14
       14
        
             };

     

       15
       15
        
             group = mkOption {

     

       16
       16
       -
               description = "Group to assign to the SEV device.";

     

       16
       16
       +
               description = lib.mdDoc "Group to assign to the SEV device.";

     

       17
       17
        
               type = types.str;

     

       18
       18
        
               default = defaultGroup;

     

       19
       19
        
             };

     

       20
       20
        
             mode = mkOption {

     

       21
       21
       -
               description = "Mode to set for the SEV device.";

     

       21
       21
       +
               description = lib.mdDoc "Mode to set for the SEV device.";

     

       22
       22
        
               type = types.str;

     

       23
       23
        
               default = "0660";

     

       24
       24
        
             };

+13 -13

nixos/modules/installer/sd-card/sd-image.nix

···

       35
       35
        
         options.sdImage = {

     

       36
       36
        
           imageName = mkOption {

     

       37
       37
        
             default = "${config.sdImage.imageBaseName}-${config.system.nixos.label}-${pkgs.stdenv.hostPlatform.system}.img";

     

       38
       38
       -
             description = ''

     

       38
       38
       +
             description = lib.mdDoc ''

     

       39
       39
        
               Name of the generated image file.

     

       40
       40
        
             '';

     

       41
       41
        
           };

     

       42
       42
        
       

     

       43
       43
        
           imageBaseName = mkOption {

     

       44
       44
        
             default = "nixos-sd-image";

     

       45
       45
       -
             description = ''

     

       45
       45
       +
             description = lib.mdDoc ''

     

       46
       46
        
               Prefix of the name of the generated image file.

     

       47
       47
        
             '';

     

       48
       48
        
           };

     
···

       50
       50
        
           storePaths = mkOption {

     

       51
       51
        
             type = with types; listOf package;

     

       52
       52
        
             example = literalExpression "[ pkgs.stdenv ]";

     

       53
       53
       -
             description = ''

     

       53
       53
       +
             description = lib.mdDoc ''

     

       54
       54
        
               Derivations to be included in the Nix store in the generated SD image.

     

       55
       55
        
             '';

     

       56
       56
        
           };

     
···

       74
       74
        
           firmwarePartitionID = mkOption {

     

       75
       75
        
             type = types.str;

     

       76
       76
        
             default = "0x2178694e";

     

       77
       77
       -
             description = ''

     

       77
       77
       +
             description = lib.mdDoc ''

     

       78
       78
        
               Volume ID for the /boot/firmware partition on the SD card. This value

     

       79
       79
        
               must be a 32-bit hexadecimal number.

     

       80
       80
        
             '';

     
···

       83
       83
        
           firmwarePartitionName = mkOption {

     

       84
       84
        
             type = types.str;

     

       85
       85
        
             default = "FIRMWARE";

     

       86
       86
       -
             description = ''

     

       86
       86
       +
             description = lib.mdDoc ''

     

       87
       87
        
               Name of the filesystem which holds the boot firmware.

     

       88
       88
        
             '';

     

       89
       89
        
           };

     
···

       92
       92
        
             type = types.nullOr types.str;

     

       93
       93
        
             default = null;

     

       94
       94
        
             example = "14e19a7b-0ae0-484d-9d54-43bd6fdc20c7";

     

       95
       95
       -
             description = ''

     

       95
       95
       +
             description = lib.mdDoc ''

     

       96
       96
        
               UUID for the filesystem on the main NixOS partition on the SD card.

     

       97
       97
        
             '';

     

       98
       98
        
           };

     
···

       101
       101
        
             type = types.int;

     

       102
       102
        
             # As of 2019-08-18 the Raspberry pi firmware + u-boot takes ~18MiB

     

       103
       103
        
             default = 30;

     

       104
       104
       -
             description = ''

     

       104
       104
       +
             description = lib.mdDoc ''

     

       105
       105
        
               Size of the /boot/firmware partition, in megabytes.

     

       106
       106
        
             '';

     

       107
       107
        
           };

     

       108
       108
        
       

     

       109
       109
        
           populateFirmwareCommands = mkOption {

     

       110
       110
        
             example = literalExpression "'' cp \${pkgs.myBootLoader}/u-boot.bin firmware/ ''";

     

       111
       111
       -
             description = ''

     

       111
       111
       +
             description = lib.mdDoc ''

     

       112
       112
        
               Shell commands to populate the ./firmware directory.

     

       113
       113
        
               All files in that directory are copied to the

     

       114
       114
        
               /boot/firmware partition on the SD image.

     
···

       117
       117
        
       

     

       118
       118
        
           populateRootCommands = mkOption {

     

       119
       119
        
             example = literalExpression "''\${config.boot.loader.generic-extlinux-compatible.populateCmd} -c \${config.system.build.toplevel} -d ./files/boot''";

     

       120
       120
       -
             description = ''

     

       120
       120
       +
             description = lib.mdDoc ''

     

       121
       121
        
               Shell commands to populate the ./files directory.

     

       122
       122
        
               All files in that directory are copied to the

     

       123
       123
        
               root (/) partition on the SD image. Use this to

     
···

       128
       128
        
           postBuildCommands = mkOption {

     

       129
       129
        
             example = literalExpression "'' dd if=\${pkgs.myBootLoader}/SPL of=$img bs=1024 seek=1 conv=notrunc ''";

     

       130
       130
        
             default = "";

     

       131
       131
       -
             description = ''

     

       131
       131
       +
             description = lib.mdDoc ''

     

       132
       132
        
               Shell commands to run after the image is built.

     

       133
       133
        
               Can be used for boards requiring to dd u-boot SPL before actual partitions.

     

       134
       134
        
             '';

     
···

       137
       137
        
           compressImage = mkOption {

     

       138
       138
        
             type = types.bool;

     

       139
       139
        
             default = true;

     

       140
       140
       -
             description = ''

     

       140
       140
       +
             description = lib.mdDoc ''

     

       141
       141
        
               Whether the SD image should be compressed using

     

       142
       142
       -
               <command>zstd</command>.

     

       142
       142
       +
               {command}`zstd`.

     

       143
       143
        
             '';

     

       144
       144
        
           };

     

       145
       145
        
       

     

       146
       146
        
           expandOnBoot = mkOption {

     

       147
       147
        
             type = types.bool;

     

       148
       148
        
             default = true;

     

       149
       149
       -
             description = ''

     

       149
       149
       +
             description = lib.mdDoc ''

     

       150
       150
        
               Whether to configure the sd image to expand it's partition on boot.

     

       151
       151
        
             '';

     

       152
       152
        
           };

+1 -1

nixos/modules/misc/documentation.nix

···

       241
       241
        
             nixos.extraModules = mkOption {

     

       242
       242
        
               type = types.listOf types.raw;

     

       243
       243
        
               default = [];

     

       244
       244
       -
               description = ''

     

       244
       244
       +
               description = lib.mdDoc ''

     

       245
       245
        
                 Modules for which to show options even when not imported.

     

       246
       246
        
               '';

     

       247
       247
        
             };

+10 -10

nixos/modules/misc/nixpkgs.nix

···

       117
       117
        
             '';

     

       118
       118
        
             type = pkgsType;

     

       119
       119
        
             example = literalExpression "import <nixpkgs> {}";

     

       120
       120
       -
             description = ''

     

       120
       120
       +
             description = lib.mdDoc ''

     

       121
       121
        
               If set, the pkgs argument to all NixOS modules is the value of

     

       122
       122
       -
               this option, extended with <literal>nixpkgs.overlays</literal>, if

     

       123
       123
       -
               that is also set. Either <literal>nixpkgs.crossSystem</literal> or

     

       124
       124
       -
               <literal>nixpkgs.localSystem</literal> will be used in an assertion

     

       122
       122
       +
               this option, extended with `nixpkgs.overlays`, if

     

       123
       123
       +
               that is also set. Either `nixpkgs.crossSystem` or

     

       124
       124
       +
               `nixpkgs.localSystem` will be used in an assertion

     

       125
       125
        
               to check that the NixOS and Nixpkgs architectures match. Any

     

       126
       126
       -
               other options in <literal>nixpkgs.*</literal>, notably <literal>config</literal>,

     

       126
       126
       +
               other options in `nixpkgs.*`, notably `config`,

     

       127
       127
        
               will be ignored.

     

       128
       128
        
       

     

       129
       129
        
               If unset, the pkgs argument to all NixOS modules is determined

     
···

       132
       132
        
               The default value imports the Nixpkgs source files

     

       133
       133
        
               relative to the location of this NixOS module, because

     

       134
       134
        
               NixOS and Nixpkgs are distributed together for consistency,

     

       135
       135
       -
               so the <literal>nixos</literal> in the default value is in fact a

     

       136
       136
       -
               relative path. The <literal>config</literal>, <literal>overlays</literal>,

     

       137
       137
       -
               <literal>localSystem</literal>, and <literal>crossSystem</literal> come

     

       135
       135
       +
               so the `nixos` in the default value is in fact a

     

       136
       136
       +
               relative path. The `config`, `overlays`,

     

       137
       137
       +
               `localSystem`, and `crossSystem` come

     

       138
       138
        
               from this option's siblings.

     

       139
       139
        
       

     

       140
       140
        
               This option can be used by applications like NixOps to increase

     

       141
       141
        
               the performance of evaluation, or to create packages that depend

     

       142
       142
        
               on a container that should be built with the exact same evaluation

     

       143
       143
        
               of Nixpkgs, for example. Applications like this should set

     

       144
       144
       -
               their default value using <literal>lib.mkDefault</literal>, so

     

       144
       144
       +
               their default value using `lib.mkDefault`, so

     

       145
       145
        
               user-provided configuration can override it without using

     

       146
       146
       -
               <literal>lib</literal>.

     

       146
       146
       +
               `lib`.

     

       147
       147
        
       

     

       148
       148
        
               Note that using a distinct version of Nixpkgs with NixOS may

     

       149
       149
        
               be an unexpected source of problems. Use this option with care.

+1 -1

nixos/modules/misc/wordlist.nix

···

       23
       23
        
                 }

     

       24
       24
        
               '';

     

       25
       25
        
       

     

       26
       26
       -
               description = ''

     

       26
       26
       +
               description = lib.mdDoc ''

     

       27
       27
        
                 A set with the key names being the environment variable you'd like to

     

       28
       28
        
                 set and the values being a list of paths to text documents containing

     

       29
       29
        
                 lists of words. The various files will be merged, sorted, duplicates

+3 -3

nixos/modules/programs/captive-browser.nix

···

       85
       85
        
             bindInterface = mkOption {

     

       86
       86
        
               default = true;

     

       87
       87
        
               type = types.bool;

     

       88
       88
       -
               description = ''

     

       89
       89
       -
                 Binds <package>captive-browser</package> to the network interface declared in

     

       90
       90
       -
                 <literal>cfg.interface</literal>. This can be used to avoid collisions

     

       88
       88
       +
               description = lib.mdDoc ''

     

       89
       89
       +
                 Binds `captive-browser` to the network interface declared in

     

       90
       90
       +
                 `cfg.interface`. This can be used to avoid collisions

     

       91
       91
        
                 with private subnets.

     

       92
       92
        
               '';

     

       93
       93
        
             };

+2 -2

nixos/modules/programs/chromium.nix

···

       76
       76
        
       

     

       77
       77
        
             extraOpts = mkOption {

     

       78
       78
        
               type = types.attrs;

     

       79
       79
       -
               description = ''

     

       79
       79
       +
               description = lib.mdDoc ''

     

       80
       80
        
                 Extra chromium policy options. A list of available policies

     

       81
       81
        
                 can be found in the Chrome Enterprise documentation:

     

       82
       82
       -
                 <link xlink:href="https://cloud.google.com/docs/chrome-enterprise/policies/">https://cloud.google.com/docs/chrome-enterprise/policies/</link>

     

       82
       82
       +
                 <https://cloud.google.com/docs/chrome-enterprise/policies/>

     

       83
       83
        
                 Make sure the selected policy is supported on Linux and your browser version.

     

       84
       84
        
               '';

     

       85
       85
        
               default = {};

+7 -7

nixos/modules/programs/k3b.nix

···

       8
       8
        
           enable = mkOption {

     

       9
       9
        
             type = types.bool;

     

       10
       10
        
             default = false;

     

       11
       11
       -
             description = ''

     

       11
       11
       +
             description = lib.mdDoc ''

     

       12
       12
        
               Whether to enable k3b, the KDE disk burning application.

     

       13
       13
        
       

     

       14
       14
       -
               Additionally to installing <package>k3b</package> enabling this will

     

       15
       15
       -
               add <literal>setuid</literal> wrappers in <literal>/run/wrappers/bin</literal>

     

       16
       16
       -
               for both <package>cdrdao</package> and <package>cdrecord</package>. On first

     

       17
       17
       -
               run you must manually configure the path of <package>cdrdae</package> and

     

       18
       18
       -
               <package>cdrecord</package> to correspond to the appropriate paths under

     

       19
       19
       -
               <literal>/run/wrappers/bin</literal> in the "Setup External Programs" menu.

     

       14
       14
       +
               Additionally to installing `k3b` enabling this will

     

       15
       15
       +
               add `setuid` wrappers in `/run/wrappers/bin`

     

       16
       16
       +
               for both `cdrdao` and `cdrecord`. On first

     

       17
       17
       +
               run you must manually configure the path of `cdrdae` and

     

       18
       18
       +
               `cdrecord` to correspond to the appropriate paths under

     

       19
       19
       +
               `/run/wrappers/bin` in the "Setup External Programs" menu.

     

       20
       20
        
             '';

     

       21
       21
        
           };

     

       22
       22
        
         };

+1 -1

nixos/modules/programs/mosh.nix

···

       17
       17
        
             type = lib.types.bool;

     

       18
       18
        
           };

     

       19
       19
        
           withUtempter = mkOption {

     

       20
       20
       -
             description = ''

     

       20
       20
       +
             description = lib.mdDoc ''

     

       21
       21
        
               Whether to enable libutempter for mosh.

     

       22
       22
        
               This is required so that mosh can write to /var/run/utmp (which can be queried with `who` to display currently connected user sessions).

     

       23
       23
        
               Note, this will add a guid wrapper for the group utmp!

+1 -1

nixos/modules/programs/msmtp.nix

···

       45
       45
        
                   passwordeval = "cat /secrets/password.txt";

     

       46
       46
        
                 };

     

       47
       47
        
               };

     

       48
       48
       -
               description = ''

     

       48
       48
       +
               description = lib.mdDoc ''

     

       49
       49
        
                 Named accounts and their respective configurations.

     

       50
       50
        
                 The special name "default" allows a default account to be defined.

     

       51
       51
        
                 See msmtp(1) for the available options.

+4 -4

nixos/modules/programs/ssh.nix

···

       93
       93
        
             extraConfig = mkOption {

     

       94
       94
        
               type = types.lines;

     

       95
       95
        
               default = "";

     

       96
       96
       -
               description = ''

     

       97
       97
       -
                 Extra configuration text prepended to <filename>ssh_config</filename>. Other generated

     

       98
       98
       -
                 options will be added after a <literal>Host *</literal> pattern.

     

       99
       99
       -
                 See <citerefentry><refentrytitle>ssh_config</refentrytitle><manvolnum>5</manvolnum></citerefentry>

     

       96
       96
       +
               description = lib.mdDoc ''

     

       97
       97
       +
                 Extra configuration text prepended to {file}`ssh_config`. Other generated

     

       98
       98
       +
                 options will be added after a `Host *` pattern.

     

       99
       99
       +
                 See {manpage}`ssh_config(5)`

     

       100
       100
        
                 for help.

     

       101
       101
        
               '';

     

       102
       102
        
             };

+1 -1

nixos/modules/programs/thefuck.nix

···

       22
       22
        
                 default = "fuck";

     

       23
       23
        
                 type = types.str;

     

       24
       24
        
       

     

       25
       25
       -
                 description = ''

     

       25
       25
       +
                 description = lib.mdDoc ''

     

       26
       26
        
                   `thefuck` needs an alias to be configured.

     

       27
       27
        
                   The default value is `fuck`, but you can use anything else as well.

     

       28
       28
        
                 '';

+5 -5

nixos/modules/programs/tsm-client.nix

···

       95
       95
        
               exclude.dir     /nix/store

     

       96
       96
        
               include.encrypt /home/.../*

     

       97
       97
        
             '';

     

       98
       98
       -
             description = ''

     

       99
       99
       -
               <literal>include.*</literal> and

     

       100
       100
       -
               <literal>exclude.*</literal> directives to be

     

       98
       98
       +
             description = lib.mdDoc ''

     

       99
       99
       +
               `include.*` and

     

       100
       100
       +
               `exclude.*` directives to be

     

       101
       101
        
               used when sending files to the IBM TSM server.

     

       102
       102
        
               The lines will be written into a file that the

     

       103
       103
       -
               <literal>inclexcl</literal>

     

       104
       104
       -
               directive in <filename>dsm.sys</filename> points to.

     

       103
       103
       +
               `inclexcl`

     

       104
       104
       +
               directive in {file}`dsm.sys` points to.

     

       105
       105
        
             '';

     

       106
       106
        
           };

     

       107
       107
        
           options.extraConfig = mkOption {

+1 -1

nixos/modules/programs/yabar.nix

···

       62
       62
        
                 to use `yabar-unstable'.

     

       63
       63
        
               '';

     

       64
       64
        
       

     

       65
       65
       -
               description = ''

     

       65
       65
       +
               description = lib.mdDoc ''

     

       66
       66
        
                 The package which contains the `yabar` binary.

     

       67
       67
        
       

     

       68
       68
        
                 Nixpkgs provides the `yabar` and `yabar-unstable`

+4 -4

nixos/modules/programs/zsh/oh-my-zsh.nix

···

       49
       49
        
               package = mkOption {

     

       50
       50
        
                 default = pkgs.oh-my-zsh;

     

       51
       51
        
                 defaultText = literalExpression "pkgs.oh-my-zsh";

     

       52
       52
       -
                 description = ''

     

       52
       52
       +
                 description = lib.mdDoc ''

     

       53
       53
        
                   Package to install for `oh-my-zsh` usage.

     

       54
       54
        
                 '';

     

       55
       55
        
       

     
···

       67
       67
        
               custom = mkOption {

     

       68
       68
        
                 default = null;

     

       69
       69
        
                 type = with types; nullOr str;

     

       70
       70
       -
                 description = ''

     

       70
       70
       +
                 description = lib.mdDoc ''

     

       71
       71
        
                   Path to a custom oh-my-zsh package to override config of oh-my-zsh.

     

       72
       72
        
                   (Can't be used along with `customPkgs`).

     

       73
       73
        
                 '';

     
···

       76
       76
        
               customPkgs = mkOption {

     

       77
       77
        
                 default = [];

     

       78
       78
        
                 type = types.listOf types.package;

     

       79
       79
       -
                 description = ''

     

       79
       79
       +
                 description = lib.mdDoc ''

     

       80
       80
        
                   List of custom packages that should be loaded into `oh-my-zsh`.

     

       81
       81
        
                 '';

     

       82
       82
        
               };

     
···

       92
       92
        
               cacheDir = mkOption {

     

       93
       93
        
                 default = "$HOME/.cache/oh-my-zsh";

     

       94
       94
        
                 type = types.str;

     

       95
       95
       -
                 description = ''

     

       95
       95
       +
                 description = lib.mdDoc ''

     

       96
       96
        
                   Cache directory to be used by `oh-my-zsh`.

     

       97
       97
        
                   Without this option it would default to the read-only nix store.

     

       98
       98
        
                 '';

+1 -1

nixos/modules/programs/zsh/zsh-autoenv.nix

···

       11
       11
        
             package = mkOption {

     

       12
       12
        
               default = pkgs.zsh-autoenv;

     

       13
       13
        
               defaultText = literalExpression "pkgs.zsh-autoenv";

     

       14
       14
       -
               description = ''

     

       14
       14
       +
               description = lib.mdDoc ''

     

       15
       15
        
                 Package to install for `zsh-autoenv` usage.

     

       16
       16
        
               '';

     

       17
       17

+1 -1

nixos/modules/programs/zsh/zsh-autosuggestions.nix

···

       24
       24
        
           strategy = mkOption {

     

       25
       25
        
             type = types.listOf (types.enum [ "history" "completion" "match_prev_cmd" ]);

     

       26
       26
        
             default = [ "history" ];

     

       27
       27
       -
             description = ''

     

       27
       27
       +
             description = lib.mdDoc ''

     

       28
       28
        
               `ZSH_AUTOSUGGEST_STRATEGY` is an array that specifies how suggestions should be generated.

     

       29
       29
        
               The strategies in the array are tried successively until a suggestion is found.

     

       30
       30
        
               There are currently three built-in strategies to choose from:

+1 -1

nixos/modules/security/acme/default.nix

···

       676
       676
        
             inheritDefaults = mkOption {

     

       677
       677
        
               default = true;

     

       678
       678
        
               example = true;

     

       679
       679
       -
               description = "Whether to inherit values set in `security.acme.defaults` or not.";

     

       679
       679
       +
               description = lib.mdDoc "Whether to inherit values set in `security.acme.defaults` or not.";

     

       680
       680
        
               type = lib.types.bool;

     

       681
       681
        
             };

     

       682
       682
        
           };

+1 -1

nixos/modules/security/dhparams.nix

···

       94
       94
        
       

     

       95
       95
        
                 <note><para>If this is <literal>false</literal> the resulting store

     

       96
       96
        
                 path will be non-deterministic and will be rebuilt every time the

     

       97
       97
       -
                 <package>openssl</package> package changes.</para></note>

     

       97
       97
       +
                 <literal>openssl</literal> package changes.</para></note>

     

       98
       98
        
               '';

     

       99
       99
        
             };

     

       100
       100

+14 -15

nixos/modules/security/pam.nix

···

       320
       320
        
             limits = mkOption {

     

       321
       321
        
               default = [];

     

       322
       322
        
               type = limitsType;

     

       323
       323
       -
               description = ''

     

       323
       323
       +
               description = lib.mdDoc ''

     

       324
       324
        
                 Attribute set describing resource limits.  Defaults to the

     

       325
       325
       -
                 value of <option>security.pam.loginLimits</option>.

     

       326
       326
       -
                 The meaning of the values is explained in <citerefentry>

     

       327
       327
       -
                 <refentrytitle>limits.conf</refentrytitle><manvolnum>5</manvolnum></citerefentry>.

     

       325
       325
       +
                 value of {option}`security.pam.loginLimits`.

     

       326
       326
       +
                 The meaning of the values is explained in {manpage}`limits.conf(5)`.

     

       328
       327
        
               '';

     

       329
       328
        
             };

     

       330
       329
        
       

     
···

       774
       773
        
                 }

     

       775
       774
        
              ];

     

       776
       775
        
       

     

       777
       777
       -
            description =

     

       778
       778
       -
              '' Define resource limits that should apply to users or groups.

     

       779
       779
       -
                 Each item in the list should be an attribute set with a

     

       780
       780
       -
                 <varname>domain</varname>, <varname>type</varname>,

     

       781
       781
       -
                 <varname>item</varname>, and <varname>value</varname>

     

       782
       782
       -
                 attribute.  The syntax and semantics of these attributes

     

       783
       783
       -
                 must be that described in <citerefentry><refentrytitle>limits.conf</refentrytitle><manvolnum>5</manvolnum></citerefentry>.

     

       776
       776
       +
            description = ''

     

       777
       777
       +
              Define resource limits that should apply to users or groups.

     

       778
       778
       +
              Each item in the list should be an attribute set with a

     

       779
       779
       +
              <varname>domain</varname>, <varname>type</varname>,

     

       780
       780
       +
              <varname>item</varname>, and <varname>value</varname>

     

       781
       781
       +
              attribute.  The syntax and semantics of these attributes

     

       782
       782
       +
              must be that described in <citerefentry><refentrytitle>limits.conf</refentrytitle><manvolnum>5</manvolnum></citerefentry>.

     

       784
       783
        
       

     

       785
       785
       -
                 Note that these limits do not apply to systemd services,

     

       786
       786
       -
                 whose limits can be changed via <option>systemd.extraConfig</option>

     

       787
       787
       -
                 instead.

     

       788
       788
       -
              '';

     

       784
       784
       +
              Note that these limits do not apply to systemd services,

     

       785
       785
       +
              whose limits can be changed via <option>systemd.extraConfig</option>

     

       786
       786
       +
              instead.

     

       787
       787
       +
            '';

     

       789
       788
        
           };

     

       790
       789
        
       

     

       791
       790
        
           security.pam.services = mkOption {

+1 -1

nixos/modules/security/sudo.nix

···

       46
       46
        
             type = types.package;

     

       47
       47
        
             default = pkgs.sudo;

     

       48
       48
        
             defaultText = literalExpression "pkgs.sudo";

     

       49
       49
       -
             description = ''

     

       49
       49
       +
             description = lib.mdDoc ''

     

       50
       50
        
               Which package to use for `sudo`.

     

       51
       51
        
             '';

     

       52
       52
        
           };

+9 -9

nixos/modules/services/cluster/hadoop/hbase.nix

···

       21
       21
        
               "hbase.cluster.distributed" = "true";

     

       22
       22
        
             };

     

       23
       23
        
             type = types.attrsOf types.anything;

     

       24
       24
       -
             description = ''

     

       24
       24
       +
             description = lib.mdDoc ''

     

       25
       25
        
               Default options for hbase-site.xml

     

       26
       26
        
             '';

     

       27
       27
        
           };

     
···

       30
       30
        
             type = with types; attrsOf anything;

     

       31
       31
        
             example = literalExpression ''

     

       32
       32
        
             '';

     

       33
       33
       -
             description = ''

     

       33
       33
       +
             description = lib.mdDoc ''

     

       34
       34
        
               Additional options and overrides for hbase-site.xml

     

       35
       35
       -
               <link xlink:href="https://github.com/apache/hbase/blob/rel/2.4.11/hbase-common/src/main/resources/hbase-default.xml"/>

     

       35
       35
       +
               <https://github.com/apache/hbase/blob/rel/2.4.11/hbase-common/src/main/resources/hbase-default.xml>

     

       36
       36
        
             '';

     

       37
       37
        
           };

     

       38
       38
        
           hbaseSiteInternal = mkOption {

     
···

       50
       50
        
               type = types.package;

     

       51
       51
        
               default = pkgs.hbase;

     

       52
       52
        
               defaultText = literalExpression "pkgs.hbase";

     

       53
       53
       -
               description = "HBase package";

     

       53
       53
       +
               description = lib.mdDoc "HBase package";

     

       54
       54
        
             };

     

       55
       55
        
       

     

       56
       56
        
             rootdir = mkOption {

     

       57
       57
       -
               description = ''

     

       57
       57
       +
               description = lib.mdDoc ''

     

       58
       58
        
                 This option will set "hbase.rootdir" in hbase-site.xml and determine

     

       59
       59
        
                 the directory shared by region servers and into which HBase persists.

     

       60
       60
        
                 The URL should be 'fully-qualified' to include the filesystem scheme.

     
···

       68
       68
        
               default = "/hbase";

     

       69
       69
        
             };

     

       70
       70
        
             zookeeperQuorum = mkOption {

     

       71
       71
       -
               description = ''

     

       71
       71
       +
               description = lib.mdDoc ''

     

       72
       72
        
                 This option will set "hbase.zookeeper.quorum" in hbase-site.xml.

     

       73
       73
        
                 Comma separated list of servers in the ZooKeeper ensemble.

     

       74
       74
        
               '';

     
···

       83
       83
        
               openFirewall = mkOption {

     

       84
       84
        
                 type = types.bool;

     

       85
       85
        
                 default = false;

     

       86
       86
       -
                 description = ''

     

       86
       86
       +
                 description = lib.mdDoc ''

     

       87
       87
        
                   Open firewall ports for HBase master.

     

       88
       88
        
                 '';

     

       89
       89
        
               };

     
···

       94
       94
        
               overrideHosts = mkOption {

     

       95
       95
        
                 type = types.bool;

     

       96
       96
        
                 default = true;

     

       97
       97
       -
                 description = ''

     

       97
       97
       +
                 description = lib.mdDoc ''

     

       98
       98
        
                   Remove /etc/hosts entries for "127.0.0.2" and "::1" defined in nixos/modules/config/networking.nix

     

       99
       99
        
                   Regionservers must be able to resolve their hostnames to their IP addresses, through PTR records

     

       100
       100
        
                   or /etc/hosts entries.

     
···

       105
       105
        
               openFirewall = mkOption {

     

       106
       106
        
                 type = types.bool;

     

       107
       107
        
                 default = false;

     

       108
       108
       -
                 description = ''

     

       108
       108
       +
                 description = lib.mdDoc ''

     

       109
       109
        
                   Open firewall ports for HBase master.

     

       110
       110
        
                 '';

     

       111
       111
        
               };

+2 -2

nixos/modules/services/continuous-integration/buildbot/worker.nix

···

       121
       121
        
             keepalive = mkOption {

     

       122
       122
        
               default = 600;

     

       123
       123
        
               type = types.int;

     

       124
       124
       -
               description = "

     

       124
       124
       +
               description = lib.mdDoc ''

     

       125
       125
        
                 This is a number that indicates how frequently keepalive messages should be sent

     

       126
       126
        
                 from the worker to the buildmaster, expressed in seconds.

     

       127
       127
       -
               ";

     

       127
       127
       +
               '';

     

       128
       128
        
             };

     

       129
       129
        
       

     

       130
       130
        
             package = mkOption {

+1 -1

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

···

       193
       193
        
         options.services.buildkite-agents = mkOption {

     

       194
       194
        
           type = types.attrsOf (types.submodule buildkiteOptions);

     

       195
       195
        
           default = {};

     

       196
       196
       -
           description = ''

     

       196
       196
       +
           description = lib.mdDoc ''

     

       197
       197
        
             Attribute set of buildkite agents.

     

       198
       198
        
             The attribute key is combined with the hostname and a unique integer to

     

       199
       199
        
             create the final agent name. This can be overridden by setting the `name`

+9 -10

nixos/modules/services/continuous-integration/hercules-ci-agent/common.nix

···

       103
       103
        
               defaultText = literalExpression ''baseDirectory + "/secrets"'';

     

       104
       104
        
             };

     

       105
       105
        
             clusterJoinTokenPath = mkOption {

     

       106
       106
       -
               description = ''

     

       106
       106
       +
               description = lib.mdDoc ''

     

       107
       107
        
                 Location of the cluster-join-token.key file.

     

       108
       108
        
       

     

       109
       109
        
                 You can retrieve the contents of the file when creating a new agent via

     

       110
       110
       -
                 <link xlink:href="https://hercules-ci.com/dashboard">https://hercules-ci.com/dashboard</link>.

     

       110
       110
       +
                 <https://hercules-ci.com/dashboard>.

     

       111
       111
        
       

     

       112
       112
        
                 As this value is confidential, it should not be in the store, but

     

       113
       113
        
                 installed using other means, such as agenix, NixOps

     

       114
       114
       -
                 <literal>deployment.keys</literal>, or manual installation.

     

       114
       114
       +
                 `deployment.keys`, or manual installation.

     

       115
       115
        
       

     

       116
       116
        
                 The contents of the file are used for authentication between the agent and the API.

     

       117
       117
        
               '';

     
···

       120
       120
        
               defaultText = literalExpression ''staticSecretsDirectory + "/cluster-join-token.key"'';

     

       121
       121
        
             };

     

       122
       122
        
             binaryCachesPath = mkOption {

     

       123
       123
       -
               description = ''

     

       123
       123
       +
               description = lib.mdDoc ''

     

       124
       124
        
                 Path to a JSON file containing binary cache secret keys.

     

       125
       125
        
       

     

       126
       126
        
                 As these values are confidential, they should not be in the store, but

     

       127
       127
        
                 copied over using other means, such as agenix, NixOps

     

       128
       128
       -
                 <literal>deployment.keys</literal>, or manual installation.

     

       128
       128
       +
                 `deployment.keys`, or manual installation.

     

       129
       129
        
       

     

       130
       130
       -
                 The format is described on <link xlink:href="https://docs.hercules-ci.com/hercules-ci-agent/binary-caches-json/">https://docs.hercules-ci.com/hercules-ci-agent/binary-caches-json/</link>.

     

       130
       130
       +
                 The format is described on <https://docs.hercules-ci.com/hercules-ci-agent/binary-caches-json/>.

     

       131
       131
        
               '';

     

       132
       132
        
               type = types.path;

     

       133
       133
        
               default = config.staticSecretsDirectory + "/binary-caches.json";

     

       134
       134
        
               defaultText = literalExpression ''staticSecretsDirectory + "/binary-caches.json"'';

     

       135
       135
        
             };

     

       136
       136
        
             secretsJsonPath = mkOption {

     

       137
       137
       -
               description = ''

     

       137
       137
       +
               description = lib.mdDoc ''

     

       138
       138
        
                 Path to a JSON file containing secrets for effects.

     

       139
       139
        
       

     

       140
       140
        
                 As these values are confidential, they should not be in the store, but

     

       141
       141
        
                 copied over using other means, such as agenix, NixOps

     

       142
       142
       -
                 <literal>deployment.keys</literal>, or manual installation.

     

       142
       142
       +
                 `deployment.keys`, or manual installation.

     

       143
       143
        
       

     

       144
       144
       -
                 The format is described on <link xlink:href="https://docs.hercules-ci.com/hercules-ci-agent/secrets-json/">https://docs.hercules-ci.com/hercules-ci-agent/secrets-json/</link>.

     

       145
       145
       -
       

     

       144
       144
       +
                 The format is described on <https://docs.hercules-ci.com/hercules-ci-agent/secrets-json/>.

     

       146
       145
        
               '';

     

       147
       146
        
               type = types.path;

     

       148
       147
        
               default = config.staticSecretsDirectory + "/secrets.json";

+3 -3

nixos/modules/services/continuous-integration/hydra/default.nix

···

       87
       87
        
               type = types.str;

     

       88
       88
        
               default = localDB;

     

       89
       89
        
               example = "dbi:Pg:dbname=hydra;host=postgres.example.org;user=foo;";

     

       90
       90
       -
               description = ''

     

       90
       90
       +
               description = lib.mdDoc ''

     

       91
       91
        
                 The DBI string for Hydra database connection.

     

       92
       92
        
       

     

       93
       93
        
                 NOTE: Attempts to set `application_name` will be overridden by

     
···

       115
       115
        
               type = types.str;

     

       116
       116
        
               default = "*";

     

       117
       117
        
               example = "localhost";

     

       118
       118
       -
               description = ''

     

       119
       119
       -
                 The hostname or address to listen on or <literal>*</literal> to listen

     

       118
       118
       +
               description = lib.mdDoc ''

     

       119
       119
       +
                 The hostname or address to listen on or `*` to listen

     

       120
       120
        
                 on all interfaces.

     

       121
       121
        
               '';

     

       122
       122
        
             };

+2 -2

nixos/modules/services/databases/foundationdb.nix

···

       97
       97
        
           openFirewall = mkOption {

     

       98
       98
        
             type        = types.bool;

     

       99
       99
        
             default     = false;

     

       100
       100
       -
             description = ''

     

       100
       100
       +
             description = lib.mdDoc ''

     

       101
       101
        
               Open the firewall ports corresponding to FoundationDB processes and coordinators

     

       102
       102
       -
               using <option>config.networking.firewall.*</option>.

     

       102
       102
       +
               using {option}`config.networking.firewall.*`.

     

       103
       103
        
             '';

     

       104
       104
        
           };

     

       105
       105

+2 -2

nixos/modules/services/databases/mongodb.nix

···

       35
       35
        
               default = pkgs.mongodb;

     

       36
       36
        
               defaultText = literalExpression "pkgs.mongodb";

     

       37
       37
        
               type = types.package;

     

       38
       38
       -
               description = "

     

       38
       38
       +
               description = lib.mdDoc ''

     

       39
       39
        
                 Which MongoDB derivation to use.

     

       40
       40
       -
               ";

     

       40
       40
       +
               '';

     

       41
       41
        
             };

     

       42
       42
        
       

     

       43
       43
        
             user = mkOption {

+2 -2

nixos/modules/services/databases/mysql.nix

···

       36
       36
        
             package = mkOption {

     

       37
       37
        
               type = types.package;

     

       38
       38
        
               example = literalExpression "pkgs.mariadb";

     

       39
       39
       -
               description = "

     

       39
       39
       +
               description = lib.mdDoc ''

     

       40
       40
        
                 Which MySQL derivation to use. MariaDB packages are supported too.

     

       41
       41
       -
               ";

     

       41
       41
       +
               '';

     

       42
       42
        
             };

     

       43
       43
        
       

     

       44
       44
        
             user = mkOption {

+3 -3

nixos/modules/services/databases/postgresql.nix

···

       79
       79
        
             authentication = mkOption {

     

       80
       80
        
               type = types.lines;

     

       81
       81
        
               default = "";

     

       82
       82
       -
               description = ''

     

       82
       82
       +
               description = lib.mdDoc ''

     

       83
       83
        
                 Defines how users authenticate themselves to the server. See the

     

       84
       84
       -
                 <link xlink:href="https://www.postgresql.org/docs/current/auth-pg-hba-conf.html">PostgreSQL documentation for pg_hba.conf</link>

     

       84
       84
       +
                 [PostgreSQL documentation for pg_hba.conf](https://www.postgresql.org/docs/current/auth-pg-hba-conf.html)

     

       85
       85
        
                 for details on the expected format of this option. By default,

     

       86
       86
        
                 peer based authentication will be used for users connecting

     

       87
       87
        
                 via the Unix socket, and md5 password authentication will be

     

       88
       88
        
                 used for users connecting via TCP. Any added rules will be

     

       89
       89
        
                 inserted above the default rules. If you'd like to replace the

     

       90
       90
       -
                 default rules entirely, you can use <function>lib.mkForce</function> in your

     

       90
       90
       +
                 default rules entirely, you can use `lib.mkForce` in your

     

       91
       91
        
                 module.

     

       92
       92
        
               '';

     

       93
       93
        
             };

+7 -6

nixos/modules/services/development/jupyter/default.nix

···

       149
       149
        
                 };

     

       150
       150
        
               }

     

       151
       151
        
             '';

     

       152
       152
       -
             description = "Declarative kernel config

     

       152
       152
       +
             description = lib.mdDoc ''

     

       153
       153
       +
               Declarative kernel config.

     

       153
       154
        
       

     

       154
       154
       -
             Kernels can be declared in any language that supports and has the required

     

       155
       155
       -
             dependencies to communicate with a jupyter server.

     

       156
       156
       -
             In python's case, it means that ipykernel package must always be included in

     

       157
       157
       -
             the list of packages of the targeted environment.

     

       158
       158
       -
             ";

     

       155
       155
       +
               Kernels can be declared in any language that supports and has the required

     

       156
       156
       +
               dependencies to communicate with a jupyter server.

     

       157
       157
       +
               In python's case, it means that ipykernel package must always be included in

     

       158
       158
       +
               the list of packages of the targeted environment.

     

       159
       159
       +
             '';

     

       159
       160
        
           };

     

       160
       161
        
         };

     

       161
       162

+1 -1

nixos/modules/services/development/lorri.nix

···

       9
       9
        
             enable = lib.mkOption {

     

       10
       10
        
               default = false;

     

       11
       11
        
               type = lib.types.bool;

     

       12
       12
       -
               description = ''

     

       12
       12
       +
               description = lib.mdDoc ''

     

       13
       13
        
                 Enables the daemon for `lorri`, a nix-shell replacement for project

     

       14
       14
        
                 development. The socket-activated daemon starts on the first request

     

       15
       15
        
                 issued by the `lorri` command.

+1 -1

nixos/modules/services/editors/infinoted.nix

···

       36
       36
        
           certificateChain = mkOption {

     

       37
       37
        
             type = types.nullOr types.path;

     

       38
       38
        
             default = null;

     

       39
       39
       -
             description = ''

     

       39
       39
       +
             description = lib.mdDoc ''

     

       40
       40
        
               Chain of CA-certificates to which our `certificateFile` is relative.

     

       41
       41
        
               Optional for TLS.

     

       42
       42
        
             '';

+3 -3

nixos/modules/services/games/asf.nix

···

       81
       81
        
       

     

       82
       82
        
           settings = mkOption {

     

       83
       83
        
             type = format.type;

     

       84
       84
       -
             description = ''

     

       85
       85
       -
               The ASF.json file, all the options are documented <link xlink:href="https://github.com/JustArchiNET/ArchiSteamFarm/wiki/Configuration#global-config">here</link>.

     

       84
       84
       +
             description = lib.mdDoc ''

     

       85
       85
       +
               The ASF.json file, all the options are documented [here](https://github.com/JustArchiNET/ArchiSteamFarm/wiki/Configuration#global-config).

     

       86
       86
        
               Do note that `AutoRestart`  and `UpdateChannel` is always to `false` respectively `0` because NixOS takes care of updating everything.

     

       87
       87
        
               `Headless` is also always set to `true` because there is no way to provide inputs via a systemd service.

     

       88
       88
       -
               You should try to keep ASF up to date since upstream does not provide support for anything but the latest version and you're exposing yourself to all kinds of issues - as is outlined <link xlink:href="https://github.com/JustArchiNET/ArchiSteamFarm/wiki/Configuration#updateperiod">here</link>.

     

       88
       88
       +
               You should try to keep ASF up to date since upstream does not provide support for anything but the latest version and you're exposing yourself to all kinds of issues - as is outlined [here](https://github.com/JustArchiNET/ArchiSteamFarm/wiki/Configuration#updateperiod).

     

       89
       89
        
             '';

     

       90
       90
        
             example = {

     

       91
       91
        
               Statistics = false;

+2 -2

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

···

       41
       41
        
           stateDir = mkOption {

     

       42
       42
        
             type = types.str;

     

       43
       43
        
             default = "/var/lib/crossfire";

     

       44
       44
       -
             description = ''

     

       44
       44
       +
             description = lib.mdDoc ''

     

       45
       45
        
               Where to store runtime data (save files, persistent items, etc).

     

       46
       46
        
       

     

       47
       47
        
               If left at the default, this will be automatically created on server

     
···

       61
       61
        
       

     

       62
       62
        
           configFiles = mkOption {

     

       63
       63
        
             type = types.attrsOf types.str;

     

       64
       64
       -
             description = ''

     

       64
       64
       +
             description = lib.mdDoc ''

     

       65
       65
        
               Text to append to the corresponding configuration files. Note that the

     

       66
       66
        
               files given in the example are *not* the complete set of files available

     

       67
       67
        
               to customize; look in /etc/crossfire after enabling the server to see

+1 -1

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

···

       41
       41
        
           stateDir = mkOption {

     

       42
       42
        
             type = types.str;

     

       43
       43
        
             default = "/var/lib/deliantra";

     

       44
       44
       -
             description = ''

     

       44
       44
       +
             description = lib.mdDoc ''

     

       45
       45
        
               Where to store runtime data (save files, persistent items, etc).

     

       46
       46
        
       

     

       47
       47
        
               If left at the default, this will be automatically created on server

+3 -3

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

···

       25
       25
        
             gameId = mkOption {

     

       26
       26
        
               type        = types.nullOr types.str;

     

       27
       27
        
               default     = null;

     

       28
       28
       -
               description = ''

     

       28
       28
       +
               description = lib.mdDoc ''

     

       29
       29
        
                 Id of the game to use. To list available games run

     

       30
       30
        
                 `minetestserver --gameid list`.

     

       31
       31
        
       

     
···

       36
       36
        
             world = mkOption {

     

       37
       37
        
               type        = types.nullOr types.path;

     

       38
       38
        
               default     = null;

     

       39
       39
       -
               description = ''

     

       39
       39
       +
               description = lib.mdDoc ''

     

       40
       40
        
                 Name of the world to use. To list available worlds run

     

       41
       41
        
                 `minetestserver --world list`.

     

       42
       42
        
       

     
···

       47
       47
        
             configPath = mkOption {

     

       48
       48
        
               type        = types.nullOr types.path;

     

       49
       49
        
               default     = null;

     

       50
       50
       -
               description = ''

     

       50
       50
       +
               description = lib.mdDoc ''

     

       51
       51
        
                 Path to the config to use.

     

       52
       52
        
       

     

       53
       53
        
                 If set to null, the config of the running user will be used:

+3 -5

nixos/modules/services/hardware/fwupd.nix

···

       15
       15
        
               DisabledPlugins=${lib.concatStringsSep ";" cfg.disabledPlugins}

     

       16
       16
        
             '';

     

       17
       17
        
           };

     

       18
       18
       -
           "fwupd/uefi.conf" = {

     

       19
       19
       -
             source = pkgs.writeText "uefi.conf" ''

     

       20
       20
       -
               [uefi]

     

       18
       18
       +
           "fwupd/uefi_capsule.conf" = {

     

       19
       19
       +
             source = pkgs.writeText "uefi_capsule.conf" ''

     

       20
       20
       +
               [uefi_capsule]

     

       21
       21
        
               OverrideESPMountPoint=${config.boot.loader.efi.efiSysMountPoint}

     

       22
       22
        
             '';

     

       23
       23
        
           };

     
···

       124
       124
        
           services.dbus.packages = [ cfg.package ];

     

       125
       125
        
       

     

       126
       126
        
           services.udev.packages = [ cfg.package ];

     

       127
       127
       -
       

     

       128
       128
       -
           services.udisks2.enable = true;

     

       129
       127
        
       

     

       130
       128
        
           systemd.packages = [ cfg.package ];

     

       131
       129
        
         };

+2 -2

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

···

       126
       126
        
                 psycopg2

     

       127
       127
        
               ];

     

       128
       128
        
             '';

     

       129
       129
       -
             description = ''

     

       129
       129
       +
             description = lib.mdDoc ''

     

       130
       130
        
               List of packages to add to propagatedBuildInputs.

     

       131
       131
        
       

     

       132
       132
       -
               A popular example is <package>python3Packages.psycopg2</package>

     

       132
       132
       +
               A popular example is `python3Packages.psycopg2`

     

       133
       133
        
               for PostgreSQL support in the recorder component.

     

       134
       134
        
             '';

     

       135
       135
        
           };

+2 -2

nixos/modules/services/logging/logrotate.nix

···

       79
       79
        
             priority = mkOption {

     

       80
       80
        
               type = types.int;

     

       81
       81
        
               default = 1000;

     

       82
       82
       -
               description = ''

     

       82
       82
       +
               description = lib.mdDoc ''

     

       83
       83
        
                 Order of this logrotate block in relation to the others. The semantics are

     

       84
       84
        
                 the same as with `lib.mkOrder`. Smaller values have a greater priority.

     

       85
       85
        
               '';

     
···

       260
       260
        
                   priority = mkOption {

     

       261
       261
        
                     type = types.int;

     

       262
       262
        
                     default = 1000;

     

       263
       263
       -
                     description = ''

     

       263
       263
       +
                     description = lib.mdDoc ''

     

       264
       264
        
                       Order of this logrotate block in relation to the others. The semantics are

     

       265
       265
        
                       the same as with `lib.mkOrder`. Smaller values are inserted first.

     

       266
       266
        
                     '';

+36 -36

nixos/modules/services/mail/postfix.nix

···

       355
       355
        
             setgidGroup = mkOption {

     

       356
       356
        
               type = types.str;

     

       357
       357
        
               default = "postdrop";

     

       358
       358
       -
               description = "

     

       358
       358
       +
               description = lib.mdDoc ''

     

       359
       359
        
                 How to call postfix setgid group (for postdrop). Should

     

       360
       360
        
                 be uniquely used group.

     

       361
       361
       -
               ";

     

       361
       361
       +
               '';

     

       362
       362
        
             };

     

       363
       363
        
       

     

       364
       364
        
             networks = mkOption {

     

       365
       365
        
               type = types.nullOr (types.listOf types.str);

     

       366
       366
        
               default = null;

     

       367
       367
        
               example = ["192.168.0.1/24"];

     

       368
       368
       -
               description = "

     

       368
       368
       +
               description = lib.mdDoc ''

     

       369
       369
        
                 Net masks for trusted - allowed to relay mail to third parties -

     

       370
       370
        
                 hosts. Leave empty to use mynetworks_style configuration or use

     

       371
       371
        
                 default (localhost-only).

     

       372
       372
       -
               ";

     

       372
       372
       +
               '';

     

       373
       373
        
             };

     

       374
       374
        
       

     

       375
       375
        
             networksStyle = mkOption {

     

       376
       376
        
               type = types.str;

     

       377
       377
        
               default = "";

     

       378
       378
       -
               description = "

     

       378
       378
       +
               description = lib.mdDoc ''

     

       379
       379
        
                 Name of standard way of trusted network specification to use,

     

       380
       380
        
                 leave blank if you specify it explicitly or if you want to use

     

       381
       381
        
                 default (localhost-only).

     

       382
       382
       -
               ";

     

       382
       382
       +
               '';

     

       383
       383
        
             };

     

       384
       384
        
       

     

       385
       385
        
             hostname = mkOption {

     

       386
       386
        
               type = types.str;

     

       387
       387
        
               default = "";

     

       388
       388
       -
               description ="

     

       388
       388
       +
               description = lib.mdDoc ''

     

       389
       389
        
                 Hostname to use. Leave blank to use just the hostname of machine.

     

       390
       390
        
                 It should be FQDN.

     

       391
       391
       -
               ";

     

       391
       391
       +
               '';

     

       392
       392
        
             };

     

       393
       393
        
       

     

       394
       394
        
             domain = mkOption {

     

       395
       395
        
               type = types.str;

     

       396
       396
        
               default = "";

     

       397
       397
       -
               description ="

     

       397
       397
       +
               description = lib.mdDoc ''

     

       398
       398
        
                 Domain to use. Leave blank to use hostname minus first component.

     

       399
       399
       -
               ";

     

       399
       399
       +
               '';

     

       400
       400
        
             };

     

       401
       401
        
       

     

       402
       402
        
             origin = mkOption {

     

       403
       403
        
               type = types.str;

     

       404
       404
        
               default = "";

     

       405
       405
       -
               description ="

     

       405
       405
       +
               description = lib.mdDoc ''

     

       406
       406
        
                 Origin to use in outgoing e-mail. Leave blank to use hostname.

     

       407
       407
       -
               ";

     

       407
       407
       +
               '';

     

       408
       408
        
             };

     

       409
       409
        
       

     

       410
       410
        
             destination = mkOption {

     

       411
       411
        
               type = types.nullOr (types.listOf types.str);

     

       412
       412
        
               default = null;

     

       413
       413
        
               example = ["localhost"];

     

       414
       414
       -
               description = "

     

       414
       414
       +
               description = lib.mdDoc ''

     

       415
       415
        
                 Full (!) list of domains we deliver locally. Leave blank for

     

       416
       416
        
                 acceptable Postfix default.

     

       417
       417
       -
               ";

     

       417
       417
       +
               '';

     

       418
       418
        
             };

     

       419
       419
        
       

     

       420
       420
        
             relayDomains = mkOption {

     

       421
       421
        
               type = types.nullOr (types.listOf types.str);

     

       422
       422
        
               default = null;

     

       423
       423
        
               example = ["localdomain"];

     

       424
       424
       -
               description = "

     

       424
       424
       +
               description = lib.mdDoc ''

     

       425
       425
        
                 List of domains we agree to relay to. Default is empty.

     

       426
       426
       -
               ";

     

       426
       426
       +
               '';

     

       427
       427
        
             };

     

       428
       428
        
       

     

       429
       429
        
             relayHost = mkOption {

     

       430
       430
        
               type = types.str;

     

       431
       431
        
               default = "";

     

       432
       432
       -
               description = "

     

       432
       432
       +
               description = lib.mdDoc ''

     

       433
       433
        
                 Mail relay for outbound mail.

     

       434
       434
       -
               ";

     

       434
       434
       +
               '';

     

       435
       435
        
             };

     

       436
       436
        
       

     

       437
       437
        
             relayPort = mkOption {

     

       438
       438
        
               type = types.int;

     

       439
       439
        
               default = 25;

     

       440
       440
       -
               description = "

     

       440
       440
       +
               description = lib.mdDoc ''

     

       441
       441
        
                 SMTP port for relay mail relay.

     

       442
       442
       -
               ";

     

       442
       442
       +
               '';

     

       443
       443
        
             };

     

       444
       444
        
       

     

       445
       445
        
             lookupMX = mkOption {

     

       446
       446
        
               type = types.bool;

     

       447
       447
        
               default = false;

     

       448
       448
       -
               description = "

     

       448
       448
       +
               description = lib.mdDoc ''

     

       449
       449
        
                 Whether relay specified is just domain whose MX must be used.

     

       450
       450
       -
               ";

     

       450
       450
       +
               '';

     

       451
       451
        
             };

     

       452
       452
        
       

     

       453
       453
        
             postmasterAlias = mkOption {

     

       454
       454
        
               type = types.str;

     

       455
       455
        
               default = "root";

     

       456
       456
       -
               description = "

     

       456
       456
       +
               description = lib.mdDoc ''

     

       457
       457
        
                 Who should receive postmaster e-mail. Multiple values can be added by

     

       458
       458
        
                 separating values with comma.

     

       459
       459
       -
               ";

     

       459
       459
       +
               '';

     

       460
       460
        
             };

     

       461
       461
        
       

     

       462
       462
        
             rootAlias = mkOption {

     

       463
       463
        
               type = types.str;

     

       464
       464
        
               default = "";

     

       465
       465
       -
               description = "

     

       465
       465
       +
               description = lib.mdDoc ''

     

       466
       466
        
                 Who should receive root e-mail. Blank for no redirection.

     

       467
       467
        
                 Multiple values can be added by separating values with comma.

     

       468
       468
       -
               ";

     

       468
       468
       +
               '';

     

       469
       469
        
             };

     

       470
       470
        
       

     

       471
       471
        
             extraAliases = mkOption {

     

       472
       472
        
               type = types.lines;

     

       473
       473
        
               default = "";

     

       474
       474
       -
               description = "

     

       474
       474
       +
               description = lib.mdDoc ''

     

       475
       475
        
                 Additional entries to put verbatim into aliases file, cf. man-page aliases(8).

     

       476
       476
       -
               ";

     

       476
       476
       +
               '';

     

       477
       477
        
             };

     

       478
       478
        
       

     

       479
       479
        
             aliasMapType = mkOption {

     
···

       497
       497
        
             extraConfig = mkOption {

     

       498
       498
        
               type = types.lines;

     

       499
       499
        
               default = "";

     

       500
       500
       -
               description = "

     

       500
       500
       +
               description = lib.mdDoc ''

     

       501
       501
        
                 Extra lines to be added verbatim to the main.cf configuration file.

     

       502
       502
       -
               ";

     

       502
       502
       +
               '';

     

       503
       503
        
             };

     

       504
       504
        
       

     

       505
       505
        
             tlsTrustedAuthorities = mkOption {

     
···

       527
       527
        
               type = types.str;

     

       528
       528
        
               default = "";

     

       529
       529
        
               example = "+";

     

       530
       530
       -
               description = "

     

       530
       530
       +
               description = lib.mdDoc ''

     

       531
       531
        
                 Delimiter for address extension: so mail to user+test can be handled by ~user/.forward+test

     

       532
       532
       -
               ";

     

       532
       532
       +
               '';

     

       533
       533
        
             };

     

       534
       534
        
       

     

       535
       535
        
             canonical = mkOption {

     
···

       543
       543
        
             virtual = mkOption {

     

       544
       544
        
               type = types.lines;

     

       545
       545
        
               default = "";

     

       546
       546
       -
               description = "

     

       546
       546
       +
               description = lib.mdDoc ''

     

       547
       547
        
                 Entries for the virtual alias map, cf. man-page virtual(5).

     

       548
       548
       -
               ";

     

       548
       548
       +
               '';

     

       549
       549
        
             };

     

       550
       550
        
       

     

       551
       551
        
             virtualMapType = mkOption {

     
···

       572
       572
        
             transport = mkOption {

     

       573
       573
        
               default = "";

     

       574
       574
        
               type = types.lines;

     

       575
       575
       -
               description = "

     

       575
       575
       +
               description = lib.mdDoc ''

     

       576
       576
        
                 Entries for the transport map, cf. man-page transport(8).

     

       577
       577
       -
               ";

     

       577
       577
       +
               '';

     

       578
       578
        
             };

     

       579
       579
        
       

     

       580
       580
        
             dnsBlacklists = mkOption {

+10 -11

nixos/modules/services/matrix/dendrite.nix

···

       26
       26
        
             type = lib.types.nullOr lib.types.path;

     

       27
       27
        
             example = "/var/lib/dendrite/server.cert";

     

       28
       28
        
             default = null;

     

       29
       29
       -
             description = ''

     

       29
       29
       +
             description = lib.mdDoc ''

     

       30
       30
        
               The path to the TLS certificate.

     

       31
       31
        
       

     

       32
       32
       -
               <programlisting>

     

       32
       32
       +
               ```

     

       33
       33
        
                 nix-shell -p dendrite --command "generate-keys --tls-cert server.crt --tls-key server.key"

     

       34
       34
       -
               </programlisting>

     

       34
       34
       +
               ```

     

       35
       35
        
             '';

     

       36
       36
        
           };

     

       37
       37
        
           tlsKey = lib.mkOption {

     

       38
       38
        
             type = lib.types.nullOr lib.types.path;

     

       39
       39
        
             example = "/var/lib/dendrite/server.key";

     

       40
       40
        
             default = null;

     

       41
       41
       -
             description = ''

     

       41
       41
       +
             description = lib.mdDoc ''

     

       42
       42
        
               The path to the TLS key.

     

       43
       43
        
       

     

       44
       44
       -
               <programlisting>

     

       44
       44
       +
               ```

     

       45
       45
        
                 nix-shell -p dendrite --command "generate-keys --tls-cert server.crt --tls-key server.key"

     

       46
       46
       -
               </programlisting>

     

       46
       46
       +
               ```

     

       47
       47
        
             '';

     

       48
       48
        
           };

     

       49
       49
        
           environmentFile = lib.mkOption {

     
···

       51
       51
        
             example = "/var/lib/dendrite/registration_secret";

     

       52
       52
        
             default = null;

     

       53
       53
        
             description = ''

     

       54
       54
       -
               Environment file as defined in <citerefentry>

     

       55
       55
       -
               <refentrytitle>systemd.exec</refentrytitle><manvolnum>5</manvolnum></citerefentry>.

     

       54
       54
       +
               Environment file as defined in <citerefentry><refentrytitle>systemd.exec</refentrytitle><manvolnum>5</manvolnum></citerefentry>.

     

       56
       55
        
               Secrets may be passed to the service without adding them to the world-readable

     

       57
       56
        
               Nix store, by specifying placeholder variables as the option value in Nix and

     

       58
       57
        
               setting these variables accordingly in the environment file. Currently only used

     
···

       103
       102
        
                     lib.types.path

     

       104
       103
        
                     (lib.types.strMatching "^\\$CREDENTIALS_DIRECTORY/.+");

     

       105
       104
        
                   example = "$CREDENTIALS_DIRECTORY/private_key";

     

       106
       106
       -
                   description = ''

     

       105
       105
       +
                   description = lib.mdDoc ''

     

       107
       106
        
                     The path to the signing private key file, used to sign

     

       108
       107
        
                     requests and events.

     

       109
       108
        
       

     

       110
       110
       -
                     <programlisting>

     

       109
       109
       +
                     ```

     

       111
       110
        
                       nix-shell -p dendrite --command "generate-keys --private-key matrix_key.pem"

     

       112
       112
       -
                     </programlisting>

     

       111
       111
       +
                     ```

     

       113
       112
        
                   '';

     

       114
       113
        
                 };

     

       115
       114
        
                 trusted_third_party_id_servers = lib.mkOption {

+1 -1

nixos/modules/services/matrix/synapse.nix

···

       516
       516
        
                     type = types.bool;

     

       517
       517
        
                     default = true;

     

       518
       518
        
                     example = false;

     

       519
       519
       -
                     description = ''

     

       519
       519
       +
                     description = lib.mdDoc ''

     

       520
       520
        
                       Is the preview URL API enabled?  If enabled, you *must* specify an

     

       521
       521
        
                       explicit url_preview_ip_range_blacklist of IPs that the spider is

     

       522
       522
        
                       denied from accessing.

+4 -4

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

···

       133
       133
        
                 };

     

       134
       134
        
               };

     

       135
       135
        
               default = {};

     

       136
       136
       -
               description = ''

     

       137
       137
       -
                 Configuration for <package>etebase-server</package>. Refer to

     

       138
       138
       -
                 <link xlink:href="https://github.com/etesync/server/blob/master/etebase-server.ini.example"/>

     

       139
       139
       -
                 and <link xlink:href="https://github.com/etesync/server/wiki"/>

     

       136
       136
       +
               description = lib.mdDoc ''

     

       137
       137
       +
                 Configuration for `etebase-server`. Refer to

     

       138
       138
       +
                 <https://github.com/etesync/server/blob/master/etebase-server.ini.example>

     

       139
       139
       +
                 and <https://github.com/etesync/server/wiki>

     

       140
       140
        
                 for details on supported values.

     

       141
       141
        
               '';

     

       142
       142
        
               example = {

+2 -2

nixos/modules/services/misc/exhibitor.nix

···

       71
       71
        
             enable = mkOption {

     

       72
       72
        
               type = types.bool;

     

       73
       73
        
               default = false;

     

       74
       74
       -
               description = "

     

       74
       74
       +
               description = lib.mdDoc ''

     

       75
       75
        
                 Whether to enable the exhibitor server.

     

       76
       76
       -
               ";

     

       76
       76
       +
               '';

     

       77
       77
        
             };

     

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

     

       79
       79
        
             # General options for any type of config

+5 -5

nixos/modules/services/misc/freeswitch.nix

···

       22
       22
        
             enableReload = mkOption {

     

       23
       23
        
               default = false;

     

       24
       24
        
               type = types.bool;

     

       25
       25
       -
               description = ''

     

       26
       26
       -
                 Issue the <literal>reloadxml</literal> command to FreeSWITCH when configuration directory changes (instead of restart).

     

       27
       27
       -
                 See <link xlink:href="https://freeswitch.org/confluence/display/FREESWITCH/Reloading">FreeSWITCH documentation</link> for more info.

     

       28
       28
       -
                 The configuration directory is exposed at <filename>/etc/freeswitch</filename>.

     

       29
       29
       -
                 See also <literal>systemd.services.*.restartIfChanged</literal>.

     

       25
       25
       +
               description = lib.mdDoc ''

     

       26
       26
       +
                 Issue the `reloadxml` command to FreeSWITCH when configuration directory changes (instead of restart).

     

       27
       27
       +
                 See [FreeSWITCH documentation](https://freeswitch.org/confluence/display/FREESWITCH/Reloading) for more info.

     

       28
       28
       +
                 The configuration directory is exposed at {file}`/etc/freeswitch`.

     

       29
       29
       +
                 See also `systemd.services.*.restartIfChanged`.

     

       30
       30
        
               '';

     

       31
       31
        
             };

     

       32
       32
        
             configTemplate = mkOption {

+12 -15

nixos/modules/services/misc/geoipupdate.nix

···

       12
       12
        
         options = {

     

       13
       13
        
           services.geoipupdate = {

     

       14
       14
        
             enable = lib.mkEnableOption ''

     

       15
       15
       -
               periodic downloading of GeoIP databases using

     

       16
       16
       -
               <productname>geoipupdate</productname>.

     

       15
       15
       +
               periodic downloading of GeoIP databases using geoipupdate.

     

       17
       16
        
             '';

     

       18
       17
        
       

     

       19
       18
        
             interval = lib.mkOption {

     
···

       36
       35
        
                   ProxyUserPassword = { _secret = "/run/keys/proxy_pass"; };

     

       37
       36
        
                 }

     

       38
       37
        
               '';

     

       39
       39
       -
               description = ''

     

       40
       40
       -
                 <productname>geoipupdate</productname> configuration

     

       41
       41
       -
                 options. See

     

       42
       42
       -
                 <link xlink:href="https://github.com/maxmind/geoipupdate/blob/main/doc/GeoIP.conf.md"/>

     

       38
       38
       +
               description = lib.mdDoc ''

     

       39
       39
       +
                 geoipupdate configuration options. See

     

       40
       40
       +
                 <https://github.com/maxmind/geoipupdate/blob/main/doc/GeoIP.conf.md>

     

       43
       41
        
                 for a full list of available options.

     

       44
       42
        
       

     

       45
       43
        
                 Settings containing secret data should be set to an

     

       46
       44
        
                 attribute set containing the attribute

     

       47
       47
       -
                 <literal>_secret</literal> - a string pointing to a file

     

       45
       45
       +
                 `_secret` - a string pointing to a file

     

       48
       46
        
                 containing the value the option should be set to. See the

     

       49
       47
        
                 example to get a better picture of this: in the resulting

     

       50
       50
       -
                 <filename>GeoIP.conf</filename> file, the

     

       51
       51
       -
                 <literal>ProxyUserPassword</literal> key will be set to the

     

       48
       48
       +
                 {file}`GeoIP.conf` file, the

     

       49
       49
       +
                 `ProxyUserPassword` key will be set to the

     

       52
       50
        
                 contents of the

     

       53
       53
       -
                 <filename>/run/keys/proxy_pass</filename> file.

     

       51
       51
       +
                 {file}`/run/keys/proxy_pass` file.

     

       54
       52
        
               '';

     

       55
       53
        
               type = lib.types.submodule {

     

       56
       54
        
                 freeformType =

     
···

       85
       83
        
       

     

       86
       84
        
                   LicenseKey = lib.mkOption {

     

       87
       85
        
                     type = with lib.types; either path (attrsOf path);

     

       88
       88
       -
                     description = ''

     

       89
       89
       -
                       A file containing the

     

       90
       90
       -
                       <productname>MaxMind</productname> license key.

     

       86
       86
       +
                     description = lib.mdDoc ''

     

       87
       87
       +
                       A file containing the MaxMind license key.

     

       91
       88
        
       

     

       92
       89
        
                       Always handled as a secret whether the value is

     

       93
       93
       -
                       wrapped in a <literal>{ _secret = ...; }</literal>

     

       94
       94
       -
                       attrset or not (refer to <xref linkend="opt-services.geoipupdate.settings"/> for

     

       90
       90
       +
                       wrapped in a `{ _secret = ...; }`

     

       91
       91
       +
                       attrset or not (refer to [](#opt-services.geoipupdate.settings) for

     

       95
       92
        
                       details).

     

       96
       93
        
                     '';

     

       97
       94
        
                     apply = x: if isAttrs x then x else { _secret = x; };

+6 -6

nixos/modules/services/misc/gitea.nix

···

       183
       183
        
               file = mkOption {

     

       184
       184
        
                 type = types.nullOr types.str;

     

       185
       185
        
                 default = null;

     

       186
       186
       -
                 description = "Filename to be used for the dump. If `null` a default name is choosen by gitea.";

     

       186
       186
       +
                 description = lib.mdDoc "Filename to be used for the dump. If `null` a default name is choosen by gitea.";

     

       187
       187
        
                 example = "gitea-dump";

     

       188
       188
        
               };

     

       189
       189
        
             };

     
···

       293
       293
        
                       default = "${cfg.stateDir}/log";

     

       294
       294
        
                       defaultText = literalExpression ''"''${config.${opt.stateDir}}/log"'';

     

       295
       295
        
                       type = types.str;

     

       296
       296
       -
                       description = "Root path for log files.";

     

       296
       296
       +
                       description = lib.mdDoc "Root path for log files.";

     

       297
       297
        
                     };

     

       298
       298
        
                     LEVEL = mkOption {

     

       299
       299
        
                       default = "Info";

     

       300
       300
        
                       type = types.enum [ "Trace" "Debug" "Info" "Warn" "Error" "Critical" ];

     

       301
       301
       -
                       description = "General log level.";

     

       301
       301
       +
                       description = lib.mdDoc "General log level.";

     

       302
       302
        
                     };

     

       303
       303
        
                   };

     

       304
       304
        
       

     
···

       306
       306
        
                     DISABLE_SSH = mkOption {

     

       307
       307
        
                       type = types.bool;

     

       308
       308
        
                       default = false;

     

       309
       309
       -
                       description = "Disable external SSH feature.";

     

       309
       309
       +
                       description = lib.mdDoc "Disable external SSH feature.";

     

       310
       310
        
                     };

     

       311
       311
        
       

     

       312
       312
        
                     SSH_PORT = mkOption {

     

       313
       313
        
                       type = types.int;

     

       314
       314
        
                       default = 22;

     

       315
       315
        
                       example = 2222;

     

       316
       316
       -
                       description = ''

     

       316
       316
       +
                       description = lib.mdDoc ''

     

       317
       317
        
                         SSH port displayed in clone URL.

     

       318
       318
        
                         The option is required to configure a service when the external visible port

     

       319
       319
        
                         differs from the local listening port i.e. if port forwarding is used.

     
···

       339
       339
        
                     COOKIE_SECURE = mkOption {

     

       340
       340
        
                       type = types.bool;

     

       341
       341
        
                       default = false;

     

       342
       342
       -
                       description = ''

     

       342
       342
       +
                       description = lib.mdDoc ''

     

       343
       343
        
                         Marks session cookies as "secure" as a hint for browsers to only send

     

       344
       344
        
                         them via HTTPS. This option is recommend, if gitea is being served over HTTPS.

     

       345
       345
        
                       '';

+6 -8

nixos/modules/services/misc/gitlab.nix

···

       338
       338
        
               default = 0;

     

       339
       339
        
               example = 48;

     

       340
       340
        
               apply = x: x * 60 * 60;

     

       341
       341
       -
               description = ''

     

       341
       341
       +
               description = lib.mdDoc ''

     

       342
       342
        
                 How long to keep the backups around, in

     

       343
       343
       -
                 hours. <literal>0</literal> means <quote>keep

     

       344
       344
       -
                 forever</quote>.

     

       343
       343
       +
                 hours. `0` means “keep forever”.

     

       345
       344
        
               '';

     

       346
       345
        
             };

     

       347
       346
        
       

     
···

       415
       414
        
             databaseHost = mkOption {

     

       416
       415
        
               type = types.str;

     

       417
       416
        
               default = "";

     

       418
       418
       -
               description = ''

     

       419
       419
       -
                 GitLab database hostname. An empty string means <quote>use

     

       420
       420
       -
                 local unix socket connection</quote>.

     

       417
       417
       +
               description = lib.mdDoc ''

     

       418
       418
       +
                 GitLab database hostname. An empty string means

     

       419
       419
       +
                 “use local unix socket connection”.

     

       421
       420
        
               '';

     

       422
       421
        
             };

     

       423
       422
        
       

     
···

       752
       751
        
               description = ''

     

       753
       752
        
                 The number of worker processes Puma should spawn. This

     

       754
       753
        
                 controls the amount of parallel Ruby code can be

     

       755
       755
       -
                 executed. GitLab recommends <quote>Number of CPU cores -

     

       756
       756
       -
                 1</quote>, but at least two.

     

       754
       754
       +
                 executed. GitLab recommends <literal>Number of CPU cores - 1</literal>, but at least two.

     

       757
       755
        
       

     

       758
       756
        
                 <note>

     

       759
       757
        
                   <para>

+12 -13

nixos/modules/services/misc/gitolite.nix

···

       14
       14
        
             enable = mkOption {

     

       15
       15
        
               type = types.bool;

     

       16
       16
        
               default = false;

     

       17
       17
       -
               description = ''

     

       17
       17
       +
               description = lib.mdDoc ''

     

       18
       18
        
                 Enable gitolite management under the

     

       19
       19
       -
                 <literal>gitolite</literal> user. After

     

       19
       19
       +
                 `gitolite` user. After

     

       20
       20
        
                 switching to a configuration with Gitolite enabled, you can

     

       21
       21
       -
                 then run <literal>git clone

     

       22
       22
       -
                 gitolite@host:gitolite-admin.git</literal> to manage it further.

     

       21
       21
       +
                 then run `git clone gitolite@host:gitolite-admin.git` to manage it further.

     

       23
       22
        
               '';

     

       24
       23
        
             };

     

       25
       24
        
       

     
···

       72
       71
        
                   @{$RC{ENABLE}} = grep { $_ ne 'desc' } @{$RC{ENABLE}}; # disable the command/feature

     

       73
       72
        
                 '''

     

       74
       73
        
               '';

     

       75
       75
       -
               description = ''

     

       76
       76
       -
                 Extra configuration to append to the default <literal>~/.gitolite.rc</literal>.

     

       74
       74
       +
               description = lib.mdDoc ''

     

       75
       75
       +
                 Extra configuration to append to the default `~/.gitolite.rc`.

     

       77
       76
        
       

     

       78
       78
       -
                 This should be Perl code that modifies the <literal>%RC</literal>

     

       79
       79
       -
                 configuration variable. The default <literal>~/.gitolite.rc</literal>

     

       80
       80
       -
                 content is generated by invoking <literal>gitolite print-default-rc</literal>,

     

       77
       77
       +
                 This should be Perl code that modifies the `%RC`

     

       78
       78
       +
                 configuration variable. The default `~/.gitolite.rc`

     

       79
       79
       +
                 content is generated by invoking `gitolite print-default-rc`,

     

       81
       80
        
                 and extra configuration from this option is appended to it. The result

     

       82
       82
       -
                 is placed to Nix store, and the <literal>~/.gitolite.rc</literal> file

     

       81
       81
       +
                 is placed to Nix store, and the `~/.gitolite.rc` file

     

       83
       82
        
                 becomes a symlink to it.

     

       84
       83
        
       

     

       85
       84
        
                 If you already have a customized (or otherwise changed)

     

       86
       86
       -
                 <literal>~/.gitolite.rc</literal> file, NixOS will refuse to replace

     

       85
       85
       +
                 `~/.gitolite.rc` file, NixOS will refuse to replace

     

       87
       86
        
                 it with a symlink, and the `gitolite-init` initialization service

     

       88
       87
        
                 will fail. In this situation, in order to use this option, you

     

       89
       88
        
                 will need to take any customizations you may have in

     

       90
       90
       -
                 <literal>~/.gitolite.rc</literal>, convert them to appropriate Perl

     

       89
       89
       +
                 `~/.gitolite.rc`, convert them to appropriate Perl

     

       91
       90
        
                 statements, add them to this option, and remove the file.

     

       92
       91
        
       

     

       93
       93
       -
                 See also the <literal>enableGitAnnex</literal> option.

     

       92
       92
       +
                 See also the `enableGitAnnex` option.

     

       94
       93
        
               '';

     

       95
       94
        
             };

     

       96
       95

+1 -1

nixos/modules/services/misc/klipper.nix

···

       82
       82
        
                     '';

     

       83
       83
        
                     configFile = mkOption {

     

       84
       84
        
                       type = path;

     

       85
       85
       -
                       description = "Path to firmware config which is generated using `klipper-genconf`";

     

       85
       85
       +
                       description = lib.mdDoc "Path to firmware config which is generated using `klipper-genconf`";

     

       86
       86
        
                     };

     

       87
       87
        
                   };

     

       88
       88
        
                 });

+10 -10

nixos/modules/services/misc/nix-daemon.nix

···

       264
       264
        
                     type = types.nullOr types.str;

     

       265
       265
        
                     default = null;

     

       266
       266
        
                     example = "/root/.ssh/id_buildhost_builduser";

     

       267
       267
       -
                     description = ''

     

       267
       267
       +
                     description = lib.mdDoc ''

     

       268
       268
        
                       The path to the SSH private key with which to authenticate on

     

       269
       269
        
                       the build machine. The private key must not have a passphrase.

     

       270
       270
        
                       If null, the building user (root on NixOS machines) must have an

     
···

       562
       562
        
                   trusted-public-keys = mkOption {

     

       563
       563
        
                     type = types.listOf types.str;

     

       564
       564
        
                     example = [ "hydra.nixos.org-1:CNHJZBh9K4tP3EKF6FkkgeVYsS3ohTl+oS0Qa8bezVs=" ];

     

       565
       565
       -
                     description = ''

     

       565
       565
       +
                     description = lib.mdDoc ''

     

       566
       566
        
                       List of public keys used to sign binary caches. If

     

       567
       567
       -
                       <option>nix.settings.trusted-public-keys</option> is enabled,

     

       567
       567
       +
                       {option}`nix.settings.trusted-public-keys` is enabled,

     

       568
       568
        
                       then Nix will use a binary from a binary cache if and only

     

       569
       569
       -
                       if it is signed by <emphasis>any</emphasis> of the keys

     

       569
       569
       +
                       if it is signed by *any* of the keys

     

       570
       570
        
                       listed here. By default, only the key for

     

       571
       571
       -
                       <uri>cache.nixos.org</uri> is included.

     

       571
       571
       +
                       `cache.nixos.org` is included.

     

       572
       572
        
                     '';

     

       573
       573
        
                   };

     

       574
       574
        
       

     
···

       605
       605
        
                     type = types.listOf types.str;

     

       606
       606
        
                     default = [ "*" ];

     

       607
       607
        
                     example = [ "@wheel" "@builders" "alice" "bob" ];

     

       608
       608
       -
                     description = ''

     

       608
       608
       +
                     description = lib.mdDoc ''

     

       609
       609
        
                       A list of names of users (separated by whitespace) that are

     

       610
       610
        
                       allowed to connect to the Nix daemon. As with

     

       611
       611
       -
                       <option>nix.settings.trusted-users</option>, you can specify groups by

     

       612
       612
       -
                       prefixing them with <literal>@</literal>. Also, you can

     

       613
       613
       -
                       allow all users by specifying <literal>*</literal>. The

     

       614
       614
       -
                       default is <literal>*</literal>. Note that trusted users are

     

       611
       611
       +
                       {option}`nix.settings.trusted-users`, you can specify groups by

     

       612
       612
       +
                       prefixing them with `@`. Also, you can

     

       613
       613
       +
                       allow all users by specifying `*`. The

     

       614
       614
       +
                       default is `*`. Note that trusted users are

     

       615
       615
        
                       always allowed to connect.

     

       616
       616
        
                     '';

     

       617
       617
        
                   };

+1 -1

nixos/modules/services/misc/rmfakecloud.nix

···

       50
       50
        
               type = with types; attrsOf str;

     

       51
       51
        
               default = { };

     

       52
       52
        
               example = { DATADIR = "/custom/path/for/rmfakecloud/data"; };

     

       53
       53
       -
               description = ''

     

       53
       53
       +
               description = lib.mdDoc ''

     

       54
       54
        
                 Extra settings in the form of a set of key-value pairs.

     

       55
       55
        
                 For tokens and secrets, use `environmentFile` instead.

     

       56
       56

+1 -1

nixos/modules/services/misc/zoneminder.nix

···

       80
       80
        
             webserver = mkOption {

     

       81
       81
        
               type = types.enum [ "nginx" "none" ];

     

       82
       82
        
               default = "nginx";

     

       83
       83
       -
               description = ''

     

       83
       83
       +
               description = lib.mdDoc ''

     

       84
       84
        
                 The webserver to configure for the PHP frontend.

     

       85
       85
        
       

     

       86
       86
        
                 Set it to `none` if you want to configure it yourself. PRs are welcome

+1 -1

nixos/modules/services/monitoring/collectd.nix

···

       52
       52
        
       

     

       53
       53
        
           buildMinimalPackage = mkOption {

     

       54
       54
        
             default = false;

     

       55
       55
       -
             description = ''

     

       55
       55
       +
             description = lib.mdDoc ''

     

       56
       56
        
               Build a minimal collectd package with only the configured `services.collectd.plugins`

     

       57
       57
        
             '';

     

       58
       58
        
             type = bool;

+2 -2

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

···

       60
       60
        
           package = mkOption {

     

       61
       61
        
             default = pkgs.datadog-agent;

     

       62
       62
        
             defaultText = literalExpression "pkgs.datadog-agent";

     

       63
       63
       -
             description = ''

     

       63
       63
       +
             description = lib.mdDoc ''

     

       64
       64
        
               Which DataDog v7 agent package to use. Note that the provided

     

       65
       65
        
               package is expected to have an overridable `pythonPackages`-attribute

     

       66
       66
        
               which configures the Python environment with the Datadog

     
···

       168
       168
        
           };

     

       169
       169
        
       

     

       170
       170
        
           checks = mkOption {

     

       171
       171
       -
             description = ''

     

       171
       171
       +
             description = lib.mdDoc ''

     

       172
       172
        
               Configuration for all Datadog checks. Keys of this attribute

     

       173
       173
        
               set will be used as the name of the check to create the

     

       174
       174
        
               appropriate configuration in `conf.d/$check.d/conf.yaml`.

+2 -2

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

···

       38
       38
        
           };

     

       39
       39
        
       

     

       40
       40
        
           settings = mkOption {

     

       41
       41
       -
             description = ''

     

       42
       42
       -
               Configuration for <package>grafana-agent</package>.

     

       41
       41
       +
             description = lib.mdDoc ''

     

       42
       42
       +
               Configuration for `grafana-agent`.

     

       43
       43
        
       

     

       44
       44
        
               See https://grafana.com/docs/agent/latest/configuration/

     

       45
       45
        
             '';

+6 -6

nixos/modules/services/monitoring/grafana-image-renderer.nix

···

       63
       63
        
                     default = "default";

     

       64
       64
        
                     type = types.enum [ "default" "reusable" "clustered" ];

     

       65
       65
        
                     description = ''

     

       66
       66
       -
                       Rendering mode of <package>grafana-image-renderer</package>:

     

       66
       66
       +
                       Rendering mode of <literal>grafana-image-renderer</literal>:

     

       67
       67
        
                       <itemizedlist>

     

       68
       68
        
                       <listitem><para><literal>default:</literal> Creates on browser-instance

     

       69
       69
        
                         per rendering request.</para></listitem>

     
···

       79
       79
        
                   args = mkOption {

     

       80
       80
        
                     type = types.listOf types.str;

     

       81
       81
        
                     default = [ "--no-sandbox" ];

     

       82
       82
       -
                     description = ''

     

       83
       83
       -
                       List of CLI flags passed to <package>chromium</package>.

     

       82
       82
       +
                     description = lib.mdDoc ''

     

       83
       83
       +
                       List of CLI flags passed to `chromium`.

     

       84
       84
        
                     '';

     

       85
       85
        
                   };

     

       86
       86
        
                 };

     
···

       89
       89
        
       

     

       90
       90
        
             default = {};

     

       91
       91
        
       

     

       92
       92
       -
             description = ''

     

       93
       93
       -
               Configuration attributes for <package>grafana-image-renderer</package>.

     

       92
       92
       +
             description = lib.mdDoc ''

     

       93
       93
       +
               Configuration attributes for `grafana-image-renderer`.

     

       94
       94
        
       

     

       95
       95
       -
               See <link xlink:href="https://github.com/grafana/grafana-image-renderer/blob/ce1f81438e5f69c7fd7c73ce08bab624c4c92e25/default.json"/>

     

       95
       95
       +
               See <https://github.com/grafana/grafana-image-renderer/blob/ce1f81438e5f69c7fd7c73ce08bab624c4c92e25/default.json>

     

       96
       96
        
               for supported values.

     

       97
       97
        
             '';

     

       98
       98
        
           };

+2 -2

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

···

       20
       20
        
           apiKeyFile = mkOption {

     

       21
       21
        
             type = types.path;

     

       22
       22
        
             example = "/run/keys/mackerel-api-key";

     

       23
       23
       -
             description = ''

     

       23
       23
       +
             description = lib.mdDoc ''

     

       24
       24
        
               Path to file containing the Mackerel API key. The file should contain a

     

       25
       25
        
               single line of the following form:

     

       26
       26
        
       

     

       27
       27
       -
               <literallayout>apikey = "EXAMPLE_API_KEY"</literallayout>

     

       27
       27
       +
               `apikey = "EXAMPLE_API_KEY"`

     

       28
       28
        
             '';

     

       29
       29
        
           };

     

       30
       30

+11 -11

nixos/modules/services/monitoring/nagios.nix

···

       91
       91
        
             enable = mkEnableOption ''<link xlink:href="http://www.nagios.org/">Nagios</link> to monitor your system or network.'';

     

       92
       92
        
       

     

       93
       93
        
             objectDefs = mkOption {

     

       94
       94
       -
               description = "

     

       94
       94
       +
               description = lib.mdDoc ''

     

       95
       95
        
                 A list of Nagios object configuration files that must define

     

       96
       96
        
                 the hosts, host groups, services and contacts for the

     

       97
       97
        
                 network that you want Nagios to monitor.

     

       98
       98
       -
               ";

     

       98
       98
       +
               '';

     

       99
       99
        
               type = types.listOf types.path;

     

       100
       100
        
               example = literalExpression "[ ./objects.cfg ]";

     

       101
       101
        
             };

     
···

       104
       104
        
               type = types.listOf types.package;

     

       105
       105
        
               default = with pkgs; [ monitoring-plugins msmtp mailutils ];

     

       106
       106
        
               defaultText = literalExpression "[pkgs.monitoring-plugins pkgs.msmtp pkgs.mailutils]";

     

       107
       107
       -
               description = "

     

       107
       107
       +
               description = ''

     

       108
       108
        
                 Packages to be added to the Nagios <envar>PATH</envar>.

     

       109
       109
        
                 Typically used to add plugins, but can be anything.

     

       110
       110
       -
               ";

     

       110
       110
       +
               '';

     

       111
       111
        
             };

     

       112
       112
        
       

     

       113
       113
        
             mainConfigFile = mkOption {

     

       114
       114
        
               type = types.nullOr types.package;

     

       115
       115
        
               default = null;

     

       116
       116
       -
               description = "

     

       116
       116
       +
               description = lib.mdDoc ''

     

       117
       117
        
                 If non-null, overrides the main configuration file of Nagios.

     

       118
       118
       -
               ";

     

       118
       118
       +
               '';

     

       119
       119
        
             };

     

       120
       120
        
       

     

       121
       121
        
             extraConfig = mkOption {

     
···

       139
       139
        
               type = types.package;

     

       140
       140
        
               default = nagiosCGICfgFile;

     

       141
       141
        
               defaultText = literalExpression "nagiosCGICfgFile";

     

       142
       142
       -
               description = "

     

       142
       142
       +
               description = lib.mdDoc ''

     

       143
       143
        
                 Derivation for the configuration file of Nagios CGI scripts

     

       144
       144
        
                 that can be used in web servers for running the Nagios web interface.

     

       145
       145
       -
               ";

     

       145
       145
       +
               '';

     

       146
       146
        
             };

     

       147
       147
        
       

     

       148
       148
        
             enableWebInterface = mkOption {

     

       149
       149
        
               type = types.bool;

     

       150
       150
        
               default = false;

     

       151
       151
       -
               description = "

     

       151
       151
       +
               description = lib.mdDoc ''

     

       152
       152
        
                 Whether to enable the Nagios web interface.  You should also

     

       153
       153
       -
                 enable Apache (<option>services.httpd.enable</option>).

     

       154
       154
       -
               ";

     

       153
       153
       +
                 enable Apache ({option}`services.httpd.enable`).

     

       154
       154
       +
               '';

     

       155
       155
        
             };

     

       156
       156
        
       

     

       157
       157
        
             virtualHost = mkOption {

+8 -9

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

···

       251
       251
        
             authorization = mkOption {

     

       252
       252
        
               type = types.nullOr types.attrs;

     

       253
       253
        
               default = null;

     

       254
       254
       -
               description = ''

     

       254
       254
       +
               description = lib.mdDoc ''

     

       255
       255
        
                 Sets the `Authorization` header on every scrape request with the configured credentials.

     

       256
       256
        
               '';

     

       257
       257
        
             };

     
···

       664
       664
        
         promTypes.dockerswarm_sd_config = mkDockerSdConfigModule {

     

       665
       665
        
           role = mkOption {

     

       666
       666
        
             type = types.enum [ "services" "tasks" "nodes" ];

     

       667
       667
       -
             description = ''

     

       667
       667
       +
             description = lib.mdDoc ''

     

       668
       668
        
               Role of the targets to retrieve. Must be `services`, `tasks`, or `nodes`.

     

       669
       669
        
             '';

     

       670
       670
        
           };

     
···

       1222
       1222
        
       

     

       1223
       1223
        
             role = mkOption {

     

       1224
       1224
        
               type = types.enum [ "instance" "baremetal" ];

     

       1225
       1225
       -
               description = ''

     

       1225
       1225
       +
               description = lib.mdDoc ''

     

       1226
       1226
        
                 Role of the targets to retrieve. Must be `instance` or `baremetal`.

     

       1227
       1227
        
               '';

     

       1228
       1228
        
             };

     
···

       1729
       1729
        
             type = with types; either bool (enum [ "syntax-only" ]);

     

       1730
       1730
        
             default = true;

     

       1731
       1731
        
             example = "syntax-only";

     

       1732
       1732
       -
             description = ''

     

       1733
       1733
       -
               Check configuration with <literal>promtool

     

       1734
       1734
       -
               check</literal>. The call to <literal>promtool</literal> is

     

       1732
       1732
       +
             description = lib.mdDoc ''

     

       1733
       1733
       +
               Check configuration with `promtool check`. The call to `promtool` is

     

       1735
       1734
        
               subject to sandboxing by Nix.

     

       1736
       1735
        
       

     

       1737
       1736
        
               If you use credentials stored in external files

     

       1738
       1738
       -
               (<literal>password_file</literal>, <literal>bearer_token_file</literal>, etc),

     

       1739
       1739
       -
               they will not be visible to <literal>promtool</literal>

     

       1737
       1737
       +
               (`password_file`, `bearer_token_file`, etc),

     

       1738
       1738
       +
               they will not be visible to `promtool`

     

       1740
       1739
        
               and it will report errors, despite a correct configuration.

     

       1741
       1741
       -
               To resolve this, you may set this option to <literal>"syntax-only"</literal>

     

       1740
       1740
       +
               To resolve this, you may set this option to `"syntax-only"`

     

       1742
       1741
        
               in order to only syntax check the Prometheus configuration.

     

       1743
       1742
        
             '';

     

       1744
       1743
        
           };

+4 -4

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

···

       33
       33
        
               work with this exporter:

     

       34
       34
        
               <programlisting>

     

       35
       35
        
               {

     

       36
       36
       -
                 <xref linkend="opt-services.prometheus.exporters.dovecot.enable"/> = true;

     

       37
       37
       -
                 <xref linkend="opt-services.prometheus.exporters.dovecot.socketPath"/> = "/var/run/dovecot2/old-stats";

     

       38
       38
       -
                 <xref linkend="opt-services.dovecot2.mailPlugins.globally.enable"/> = [ "old_stats" ];

     

       39
       39
       -
                 <xref linkend="opt-services.dovecot2.extraConfig"/> = '''

     

       36
       36
       +
                 services.prometheus.exporters.dovecot.enable = true;

     

       37
       37
       +
                 services.prometheus.exporters.dovecot.socketPath = "/var/run/dovecot2/old-stats";

     

       38
       38
       +
                 services.dovecot2.mailPlugins.globally.enable = [ "old_stats" ];

     

       39
       39
       +
                 services.dovecot2.extraConfig = '''

     

       40
       40
        
                   service old-stats {

     

       41
       41
        
                     unix_listener old-stats {

     

       42
       42
        
                       user = dovecot-exporter

+2 -2

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

···

       11
       11
        
             type = types.str;

     

       12
       12
        
             default = "${pkgs.knot-dns.out}/lib/libknot.so";

     

       13
       13
        
             defaultText = literalExpression ''"''${pkgs.knot-dns.out}/lib/libknot.so"'';

     

       14
       14
       -
             description = ''

     

       15
       15
       -
               Path to the library of <package>knot-dns</package>.

     

       14
       14
       +
             description = lib.mdDoc ''

     

       15
       15
       +
               Path to the library of `knot-dns`.

     

       16
       16
        
             '';

     

       17
       17
        
           };

     

       18
       18

+1 -1

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

···

       121
       121
        
               It's possible to work around the issue with a config like this:

     

       122
       122
        
               <programlisting>

     

       123
       123
        
               {

     

       124
       124
       -
                 <link linkend="opt-services.rspamd.locals._name_.text">services.rspamd.locals."multimap.conf".text</link> = '''

     

       124
       124
       +
                 services.rspamd.locals."multimap.conf".text = '''

     

       125
       125
        
                   ALLOWLIST_PROMETHEUS {

     

       126
       126
        
                     filter = "email:domain:tld";

     

       127
       127
        
                     type = "from";

+1 -1

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

···

       10
       10
        
           settings = mkOption {

     

       11
       11
        
             type = types.attrs;

     

       12
       12
        
             default = {};

     

       13
       13
       -
             description = ''

     

       13
       13
       +
             description = lib.mdDoc ''

     

       14
       14
        
               All settings of nginxlog expressed as an Nix attrset.

     

       15
       15
        
       

     

       16
       16
        
               Check the official documentation for the corresponding YAML

+5 -5

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

···

       12
       12
        
             example = "/run/keys/ldap_pass";

     

       13
       13
        
             description = ''

     

       14
       14
        
               Environment file to contain the credentials to authenticate against

     

       15
       15
       -
               <package>openldap</package>.

     

       15
       15
       +
               <literal>openldap</literal>.

     

       16
       16
        
       

     

       17
       17
        
               The file should look like this:

     

       18
       18
        
               <programlisting>

     
···

       26
       26
        
             default = "tcp";

     

       27
       27
        
             example = "udp";

     

       28
       28
        
             type = types.str;

     

       29
       29
       -
             description = ''

     

       30
       30
       -
               Which protocol to use to connect against <package>openldap</package>.

     

       29
       29
       +
             description = lib.mdDoc ''

     

       30
       30
       +
               Which protocol to use to connect against `openldap`.

     

       31
       31
        
             '';

     

       32
       32
        
           };

     

       33
       33
        
           ldapAddr = mkOption {

     

       34
       34
        
             default = "localhost:389";

     

       35
       35
        
             type = types.str;

     

       36
       36
       -
             description = ''

     

       37
       37
       -
               Address of the <package>openldap</package>-instance.

     

       36
       36
       +
             description = lib.mdDoc ''

     

       37
       37
       +
               Address of the `openldap`-instance.

     

       38
       38
        
             '';

     

       39
       39
        
           };

     

       40
       40
        
           metricsPath = mkOption {

+1 -1

nixos/modules/services/monitoring/riemann-tools.nix

···

       37
       37
        
             extraArgs = mkOption {

     

       38
       38
        
               type = types.listOf types.str;

     

       39
       39
        
               default = [];

     

       40
       40
       -
               description = ''

     

       40
       40
       +
               description = lib.mdDoc ''

     

       41
       41
        
                 A list of commandline-switches forwarded to a riemann-tool.

     

       42
       42
        
                 See for example `riemann-health --help` for available options.

     

       43
       43
        
               '';

+3 -3

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

···

       111
       111
        
               uuid = mkOption {

     

       112
       112
        
                 example = "eacb6bab-f444-4ebf-a06a-3f72d7465e40";

     

       113
       113
        
                 type = types.str;

     

       114
       114
       -
                 description = ''

     

       114
       114
       +
                 description = lib.mdDoc ''

     

       115
       115
        
                   Must be set to a unique identifier, preferably a UUID according to

     

       116
       116
        
                   RFC 4122. UUIDs can be generated with `uuidgen` command, found in

     

       117
       117
        
                   the `util-linux` package.

     
···

       236
       236
        
               uuid = mkOption {

     

       237
       237
        
                 example = "eacb6bab-f444-4ebf-a06a-3f72d7465e41";

     

       238
       238
        
                 type = types.str;

     

       239
       239
       -
                 description = ''

     

       239
       239
       +
                 description = lib.mdDoc ''

     

       240
       240
        
                   Must be set to a unique identifier, preferably a UUID according to

     

       241
       241
        
                   RFC 4122. UUIDs can be generated with `uuidgen` command, found in

     

       242
       242
        
                   the `util-linux` package.

     
···

       379
       379
        
               uuid = mkOption {

     

       380
       380
        
                 example = "eacb6bab-f444-4ebf-a06a-3f72d7465e42";

     

       381
       381
        
                 type = types.str;

     

       382
       382
       -
                 description = ''

     

       382
       382
       +
                 description = lib.mdDoc ''

     

       383
       383
        
                   Must be set to a unique identifier, preferably a UUID according to

     

       384
       384
        
                   RFC 4122. UUIDs can be generated with `uuidgen` command, found in

     

       385
       385
        
                   the `util-linux` package.

+2 -2

nixos/modules/services/network-filesystems/yandex-disk.nix

···

       23
       23
        
             enable = mkOption {

     

       24
       24
        
               type = types.bool;

     

       25
       25
        
               default = false;

     

       26
       26
       -
               description = "

     

       26
       26
       +
               description = lib.mdDoc ''

     

       27
       27
        
                 Whether to enable Yandex-disk client. See https://disk.yandex.ru/

     

       28
       28
       -
               ";

     

       28
       28
       +
               '';

     

       29
       29
        
             };

     

       30
       30
        
       

     

       31
       31
        
             username = mkOption {

+20 -20

nixos/modules/services/networking/bind.nix

···

       117
       117
        
             cacheNetworks = mkOption {

     

       118
       118
        
               default = [ "127.0.0.0/24" ];

     

       119
       119
        
               type = types.listOf types.str;

     

       120
       120
       -
               description = "

     

       120
       120
       +
               description = lib.mdDoc ''

     

       121
       121
        
                 What networks are allowed to use us as a resolver.  Note

     

       122
       122
        
                 that this is for recursive queries -- all networks are

     

       123
       123
        
                 allowed to query zones configured with the `zones` option.

     

       124
       124
        
                 It is recommended that you limit cacheNetworks to avoid your

     

       125
       125
        
                 server being used for DNS amplification attacks.

     

       126
       126
       -
               ";

     

       126
       126
       +
               '';

     

       127
       127
        
             };

     

       128
       128
        
       

     

       129
       129
        
             blockedNetworks = mkOption {

     

       130
       130
        
               default = [ ];

     

       131
       131
        
               type = types.listOf types.str;

     

       132
       132
       -
               description = "

     

       132
       132
       +
               description = lib.mdDoc ''

     

       133
       133
        
                 What networks are just blocked.

     

       134
       134
       -
               ";

     

       134
       134
       +
               '';

     

       135
       135
        
             };

     

       136
       136
        
       

     

       137
       137
        
             ipv4Only = mkOption {

     

       138
       138
        
               default = false;

     

       139
       139
        
               type = types.bool;

     

       140
       140
       -
               description = "

     

       140
       140
       +
               description = lib.mdDoc ''

     

       141
       141
        
                 Only use ipv4, even if the host supports ipv6.

     

       142
       142
       -
               ";

     

       142
       142
       +
               '';

     

       143
       143
        
             };

     

       144
       144
        
       

     

       145
       145
        
             forwarders = mkOption {

     

       146
       146
        
               default = config.networking.nameservers;

     

       147
       147
        
               defaultText = literalExpression "config.networking.nameservers";

     

       148
       148
        
               type = types.listOf types.str;

     

       149
       149
       -
               description = "

     

       149
       149
       +
               description = lib.mdDoc ''

     

       150
       150
        
                 List of servers we should forward requests to.

     

       151
       151
       -
               ";

     

       151
       151
       +
               '';

     

       152
       152
        
             };

     

       153
       153
        
       

     

       154
       154
        
             forward = mkOption {

     

       155
       155
        
               default = "first";

     

       156
       156
        
               type = types.enum ["first" "only"];

     

       157
       157
       -
               description = "

     

       157
       157
       +
               description = lib.mdDoc ''

     

       158
       158
        
                 Whether to forward 'first' (try forwarding but lookup directly if forwarding fails) or 'only'.

     

       159
       159
       -
               ";

     

       159
       159
       +
               '';

     

       160
       160
        
             };

     

       161
       161
        
       

     

       162
       162
        
             listenOn = mkOption {

     

       163
       163
        
               default = [ "any" ];

     

       164
       164
        
               type = types.listOf types.str;

     

       165
       165
       -
               description = "

     

       165
       165
       +
               description = lib.mdDoc ''

     

       166
       166
        
                 Interfaces to listen on.

     

       167
       167
       -
               ";

     

       167
       167
       +
               '';

     

       168
       168
        
             };

     

       169
       169
        
       

     

       170
       170
        
             listenOnIpv6 = mkOption {

     

       171
       171
        
               default = [ "any" ];

     

       172
       172
        
               type = types.listOf types.str;

     

       173
       173
       -
               description = "

     

       173
       173
       +
               description = lib.mdDoc ''

     

       174
       174
        
                 Ipv6 interfaces to listen on.

     

       175
       175
       -
               ";

     

       175
       175
       +
               '';

     

       176
       176
        
             };

     

       177
       177
        
       

     

       178
       178
        
             directory = mkOption {

     
···

       184
       184
        
             zones = mkOption {

     

       185
       185
        
               default = [ ];

     

       186
       186
        
               type = with types; coercedTo (listOf attrs) bindZoneCoerce (attrsOf (types.submodule bindZoneOptions));

     

       187
       187
       -
               description = "

     

       187
       187
       +
               description = lib.mdDoc ''

     

       188
       188
        
                 List of zones we claim authority over.

     

       189
       189
       -
               ";

     

       189
       189
       +
               '';

     

       190
       190
        
               example = {

     

       191
       191
        
                 "example.com" = {

     

       192
       192
        
                   master = false;

     
···

       201
       201
        
             extraConfig = mkOption {

     

       202
       202
        
               type = types.lines;

     

       203
       203
        
               default = "";

     

       204
       204
       -
               description = "

     

       204
       204
       +
               description = lib.mdDoc ''

     

       205
       205
        
                 Extra lines to be added verbatim to the generated named configuration file.

     

       206
       206
       -
               ";

     

       206
       206
       +
               '';

     

       207
       207
        
             };

     

       208
       208
        
       

     

       209
       209
        
             extraOptions = mkOption {

     
···

       219
       219
        
               type = types.path;

     

       220
       220
        
               default = confFile;

     

       221
       221
        
               defaultText = literalExpression "confFile";

     

       222
       222
       -
               description = "

     

       222
       222
       +
               description = lib.mdDoc ''

     

       223
       223
        
                 Overridable config file to use for named. By default, that

     

       224
       224
        
                 generated by nixos.

     

       225
       225
       -
               ";

     

       225
       225
       +
               '';

     

       226
       226
        
             };

     

       227
       227
        
       

     

       228
       228
        
           };

+1 -1

nixos/modules/services/networking/cloudflare-dyndns.nix

···

       13
       13
        
             apiTokenFile = mkOption {

     

       14
       14
        
               type = types.nullOr types.str;

     

       15
       15
        
               default = null;

     

       16
       16
       -
               description = ''

     

       16
       16
       +
               description = lib.mdDoc ''

     

       17
       17
        
                 The path to a file containing the CloudFlare API token.

     

       18
       18
        
       

     

       19
       19
        
                 The file must have the form `CLOUDFLARE_API_TOKEN=...`

+3 -3

nixos/modules/services/networking/create_ap.nix

···

       12
       12
        
             settings = mkOption {

     

       13
       13
        
               type = with types; attrsOf (oneOf [ int bool str ]);

     

       14
       14
        
               default = {};

     

       15
       15
       -
               description = ''

     

       16
       16
       -
                 Configuration for <package>create_ap</package>.

     

       17
       17
       -
                 See <link xlink:href="https://raw.githubusercontent.com/lakinduakash/linux-wifi-hotspot/master/src/scripts/create_ap.conf">upstream example configuration</link>

     

       15
       15
       +
               description = lib.mdDoc ''

     

       16
       16
       +
                 Configuration for `create_ap`.

     

       17
       17
       +
                 See [upstream example configuration](https://raw.githubusercontent.com/lakinduakash/linux-wifi-hotspot/master/src/scripts/create_ap.conf)

     

       18
       18
        
                 for supported values.

     

       19
       19
        
               '';

     

       20
       20
        
               example = {

+1 -1

nixos/modules/services/networking/dhcpcd.nix

···

       155
       155
        
             type = types.lines;

     

       156
       156
        
             default = "";

     

       157
       157
        
             example = "if [[ $reason =~ BOUND ]]; then echo $interface: Routers are $new_routers - were $old_routers; fi";

     

       158
       158
       -
             description = ''

     

       158
       158
       +
             description = lib.mdDoc ''

     

       159
       159
        
                Shell code that will be run after all other hooks. See

     

       160
       160
        
                `man dhcpcd-run-hooks` for details on what is possible.

     

       161
       161
        
             '';

+1 -1

nixos/modules/services/networking/ferm.nix

···

       20
       20
        
             enable = mkOption {

     

       21
       21
        
               default = false;

     

       22
       22
        
               type = types.bool;

     

       23
       23
       -
               description = ''

     

       23
       23
       +
               description = lib.mdDoc ''

     

       24
       24
        
                 Whether to enable Ferm Firewall.

     

       25
       25
        
                 *Warning*: Enabling this service WILL disable the existing NixOS

     

       26
       26
        
                 firewall! Default firewall rules provided by packages are not

+23 -23

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

···

       55
       55
        
               type = lib.types.package;

     

       56
       56
        
               default = pkgs.syncstorage-rs;

     

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

     

       58
       58
       -
               description = ''

     

       58
       58
       +
               description = lib.mdDoc ''

     

       59
       59
        
                 Package to use.

     

       60
       60
        
               '';

     

       61
       61
        
             };

     
···

       66
       66
        
               # behavior ever change.

     

       67
       67
        
               type = lib.types.strMatching "[a-z_][a-z0-9_]*";

     

       68
       68
        
               default = defaultDatabase;

     

       69
       69
       -
               description = ''

     

       69
       69
       +
               description = lib.mdDoc ''

     

       70
       70
        
                 Database to use for storage. Will be created automatically if it does not exist

     

       71
       71
       -
                 and <literal>config.${opt.database.createLocally}</literal> is set.

     

       71
       71
       +
                 and `config.${opt.database.createLocally}` is set.

     

       72
       72
        
               '';

     

       73
       73
        
             };

     

       74
       74
        
       

     

       75
       75
        
             database.user = lib.mkOption {

     

       76
       76
        
               type = lib.types.str;

     

       77
       77
        
               default = defaultUser;

     

       78
       78
       -
               description = ''

     

       78
       78
       +
               description = lib.mdDoc ''

     

       79
       79
        
                 Username for database connections.

     

       80
       80
        
               '';

     

       81
       81
        
             };

     
···

       83
       83
        
             database.host = lib.mkOption {

     

       84
       84
        
               type = lib.types.str;

     

       85
       85
        
               default = "localhost";

     

       86
       86
       -
               description = ''

     

       87
       87
       -
                 Database host name. <literal>localhost</literal> is treated specially and inserts

     

       86
       86
       +
               description = lib.mdDoc ''

     

       87
       87
       +
                 Database host name. `localhost` is treated specially and inserts

     

       88
       88
        
                 systemd dependencies, other hostnames or IP addresses of the local machine do not.

     

       89
       89
        
               '';

     

       90
       90
        
             };

     
···

       92
       92
        
             database.createLocally = lib.mkOption {

     

       93
       93
        
               type = lib.types.bool;

     

       94
       94
        
               default = true;

     

       95
       95
       -
               description = ''

     

       95
       95
       +
               description = lib.mdDoc ''

     

       96
       96
        
                 Whether to create database and user on the local machine if they do not exist.

     

       97
       97
        
                 This includes enabling unix domain socket authentication for the configured user.

     

       98
       98
        
               '';

     
···

       101
       101
        
             logLevel = lib.mkOption {

     

       102
       102
        
               type = lib.types.str;

     

       103
       103
        
               default = "error";

     

       104
       104
       -
               description = ''

     

       105
       105
       -
                 Log level to run with. This can be a simple log level like <literal>error</literal>

     

       106
       106
       -
                 or <literal>trace</literal>, or a more complicated logging expression.

     

       104
       104
       +
               description = lib.mdDoc ''

     

       105
       105
       +
                 Log level to run with. This can be a simple log level like `error`

     

       106
       106
       +
                 or `trace`, or a more complicated logging expression.

     

       107
       107
        
               '';

     

       108
       108
        
             };

     

       109
       109
        
       

     

       110
       110
        
             secrets = lib.mkOption {

     

       111
       111
        
               type = lib.types.path;

     

       112
       112
       -
               description = ''

     

       112
       112
       +
               description = lib.mdDoc ''

     

       113
       113
        
                 A file containing the various secrets. Should be in the format expected by systemd's

     

       114
       114
       -
                 <literal>EnvironmentFile</literal> directory. Two secrets are currently available:

     

       115
       115
       -
                 <literal>SYNC_MASTER_SECRET</literal> and

     

       116
       116
       -
                 <literal>SYNC_TOKENSERVER__FXA_METRICS_HASH_SECRET</literal>.

     

       114
       114
       +
                 `EnvironmentFile` directory. Two secrets are currently available:

     

       115
       115
       +
                 `SYNC_MASTER_SECRET` and

     

       116
       116
       +
                 `SYNC_TOKENSERVER__FXA_METRICS_HASH_SECRET`.

     

       117
       117
        
               '';

     

       118
       118
        
             };

     

       119
       119
        
       

     
···

       126
       126
        
       

     

       127
       127
        
               hostname = lib.mkOption {

     

       128
       128
        
                 type = lib.types.str;

     

       129
       129
       -
                 description = ''

     

       129
       129
       +
                 description = lib.mdDoc ''

     

       130
       130
        
                   Host name to use for this service.

     

       131
       131
        
                 '';

     

       132
       132
        
               };

     
···

       134
       134
        
               capacity = lib.mkOption {

     

       135
       135
        
                 type = lib.types.ints.unsigned;

     

       136
       136
        
                 default = 10;

     

       137
       137
       -
                 description = ''

     

       137
       137
       +
                 description = lib.mdDoc ''

     

       138
       138
        
                   How many sync accounts are allowed on this server. Setting this value

     

       139
       139
        
                   equal to or less than the number of currently active accounts will

     

       140
       140
        
                   effectively deny service to accounts not yet registered here.

     
···

       147
       147
        
                 defaultText = lib.literalExpression ''

     

       148
       148
        
                   ''${if cfg.singleNode.enableTLS then "https" else "http"}://''${config.${opt.singleNode.hostname}}

     

       149
       149
        
                 '';

     

       150
       150
       -
                 description = ''

     

       150
       150
       +
                 description = lib.mdDoc ''

     

       151
       151
        
                   URL of the host. If you are not using the automatic webserver proxy setup you will have

     

       152
       152
        
                   to change this setting or your sync server may not be functional.

     

       153
       153
        
                 '';

     
···

       162
       162
        
                   port = lib.mkOption {

     

       163
       163
        
                     type = lib.types.port;

     

       164
       164
        
                     default = 5000;

     

       165
       165
       -
                     description = ''

     

       165
       165
       +
                     description = lib.mdDoc ''

     

       166
       166
        
                       Port to bind to.

     

       167
       167
        
                     '';

     

       168
       168
        
                   };

     
···

       170
       170
        
                   tokenserver.enabled = lib.mkOption {

     

       171
       171
        
                     type = lib.types.bool;

     

       172
       172
        
                     default = true;

     

       173
       173
       -
                     description = ''

     

       173
       173
       +
                     description = lib.mdDoc ''

     

       174
       174
        
                       Whether to enable the token service as well.

     

       175
       175
        
                     '';

     

       176
       176
        
                   };

     

       177
       177
        
                 };

     

       178
       178
        
               };

     

       179
       179
        
               default = { };

     

       180
       180
       -
               description = ''

     

       180
       180
       +
               description = lib.mdDoc ''

     

       181
       181
        
                 Settings for the sync server. These take priority over values computed

     

       182
       182
        
                 from NixOS options.

     

       183
       183
        
       

     

       184
       184
       -
                 See the doc comments on the <literal>Settings</literal> structs in

     

       185
       185
       -
                 <link xlink:href="https://github.com/mozilla-services/syncstorage-rs/blob/master/syncstorage/src/settings.rs" />

     

       184
       184
       +
                 See the doc comments on the `Settings` structs in

     

       185
       185
       +
                 <https://github.com/mozilla-services/syncstorage-rs/blob/master/syncstorage/src/settings.rs>

     

       186
       186
        
                 and

     

       187
       187
       -
                 <link xlink:href="https://github.com/mozilla-services/syncstorage-rs/blob/master/syncstorage/src/tokenserver/settings.rs" />

     

       187
       187
       +
                 <https://github.com/mozilla-services/syncstorage-rs/blob/master/syncstorage/src/tokenserver/settings.rs>

     

       188
       188
        
                 for available options.

     

       189
       189
        
               '';

     

       190
       190
        
             };

+1 -1

nixos/modules/services/networking/fireqos.nix

···

       10
       10
        
           enable = mkOption {

     

       11
       11
        
             type = types.bool;

     

       12
       12
        
             default = false;

     

       13
       13
       -
             description = ''

     

       13
       13
       +
             description = lib.mdDoc ''

     

       14
       14
        
               If enabled, FireQOS will be launched with the specified

     

       15
       15
        
               configuration given in `config`.

     

       16
       16
        
             '';

+3 -3

nixos/modules/services/networking/ghostunnel.nix

···

       37
       37
        
               };

     

       38
       38
        
       

     

       39
       39
        
               keystore = mkOption {

     

       40
       40
       -
                 description = ''

     

       40
       40
       +
                 description = lib.mdDoc ''

     

       41
       41
        
                   Path to keystore (combined PEM with cert/key, or PKCS12 keystore).

     

       42
       42
        
       

     

       43
       43
       -
                   NB: storepass is not supported because it would expose credentials via <literal>/proc/*/cmdline</literal>.

     

       43
       43
       +
                   NB: storepass is not supported because it would expose credentials via `/proc/*/cmdline`.

     

       44
       44
        
       

     

       45
       45
       -
                   Specify this or <literal>cert</literal> and <literal>key</literal>.

     

       45
       45
       +
                   Specify this or `cert` and `key`.

     

       46
       46
        
                 '';

     

       47
       47
        
                 type = types.nullOr types.str;

     

       48
       48
        
                 default = null;

+1 -1

nixos/modules/services/networking/gnunet.nix

···

       123
       123
        
             extraOptions = mkOption {

     

       124
       124
        
               type = types.lines;

     

       125
       125
        
               default = "";

     

       126
       126
       -
               description = ''

     

       126
       126
       +
               description = lib.mdDoc ''

     

       127
       127
        
                 Additional options that will be copied verbatim in `gnunet.conf'.

     

       128
       128
        
                 See `gnunet.conf(5)' for details.

     

       129
       129
        
               '';

+1 -1

nixos/modules/services/networking/headscale.nix

···

       216
       216
        
               magicDns = mkOption {

     

       217
       217
        
                 type = types.bool;

     

       218
       218
        
                 default = true;

     

       219
       219
       -
                 description = ''

     

       219
       219
       +
                 description = lib.mdDoc ''

     

       220
       220
        
                   Whether to use [MagicDNS](https://tailscale.com/kb/1081/magicdns/).

     

       221
       221
        
                   Only works if there is at least a nameserver defined.

     

       222
       222
        
                 '';

+2 -2

nixos/modules/services/networking/hylafax/options.nix

···

       235
       235
        
               InternationalPrefix = "00";

     

       236
       236
        
               LongDistancePrefix = "0";

     

       237
       237
        
             };

     

       238
       238
       -
             description = ''

     

       238
       238
       +
             description = lib.mdDoc ''

     

       239
       239
        
               Attribute set of default values for

     

       240
       240
       -
               modem config files <filename>etc/config.*</filename>.

     

       240
       240
       +
               modem config files {file}`etc/config.*`.

     

       241
       241
        
               ${commonDescr}

     

       242
       242
        
               Think twice before changing

     

       243
       243
        
               paths of fax-processing scripts.

+16 -16

nixos/modules/services/networking/ircd-hybrid/default.nix

···

       41
       41
        
             serverName = mkOption {

     

       42
       42
        
               default = "hades.arpa";

     

       43
       43
        
               type = types.str;

     

       44
       44
       -
               description = "

     

       44
       44
       +
               description = lib.mdDoc ''

     

       45
       45
        
                 IRCD server name.

     

       46
       46
       -
               ";

     

       46
       46
       +
               '';

     

       47
       47
        
             };

     

       48
       48
        
       

     

       49
       49
        
             sid = mkOption {

     

       50
       50
        
               default = "0NL";

     

       51
       51
        
               type = types.str;

     

       52
       52
       -
               description = "

     

       52
       52
       +
               description = lib.mdDoc ''

     

       53
       53
        
                 IRCD server unique ID in a net of servers.

     

       54
       54
       -
               ";

     

       54
       54
       +
               '';

     

       55
       55
        
             };

     

       56
       56
        
       

     

       57
       57
        
             description = mkOption {

     

       58
       58
        
               default = "Hybrid-7 IRC server.";

     

       59
       59
        
               type = types.str;

     

       60
       60
       -
               description = "

     

       60
       60
       +
               description = lib.mdDoc ''

     

       61
       61
        
                 IRCD server description.

     

       62
       62
       -
               ";

     

       62
       62
       +
               '';

     

       63
       63
        
             };

     

       64
       64
        
       

     

       65
       65
        
             rsaKey = mkOption {

     

       66
       66
        
               default = null;

     

       67
       67
        
               example = literalExpression "/root/certificates/irc.key";

     

       68
       68
        
               type = types.nullOr types.path;

     

       69
       69
       -
               description = "

     

       69
       69
       +
               description = lib.mdDoc ''

     

       70
       70
        
                 IRCD server RSA key.

     

       71
       71
       -
               ";

     

       71
       71
       +
               '';

     

       72
       72
        
             };

     

       73
       73
        
       

     

       74
       74
        
             certificate = mkOption {

     

       75
       75
        
               default = null;

     

       76
       76
        
               example = literalExpression "/root/certificates/irc.pem";

     

       77
       77
        
               type = types.nullOr types.path;

     

       78
       78
       -
               description = "

     

       78
       78
       +
               description = lib.mdDoc ''

     

       79
       79
        
                 IRCD server SSL certificate. There are some limitations - read manual.

     

       80
       80
       -
               ";

     

       80
       80
       +
               '';

     

       81
       81
        
             };

     

       82
       82
        
       

     

       83
       83
        
             adminEmail = mkOption {

     

       84
       84
        
               default = "<bit-bucket@example.com>";

     

       85
       85
        
               type = types.str;

     

       86
       86
        
               example = "<name@domain.tld>";

     

       87
       87
       -
               description = "

     

       87
       87
       +
               description = lib.mdDoc ''

     

       88
       88
        
                 IRCD server administrator e-mail.

     

       89
       89
       -
               ";

     

       89
       89
       +
               '';

     

       90
       90
        
             };

     

       91
       91
        
       

     

       92
       92
        
             extraIPs = mkOption {

     

       93
       93
        
               default = [];

     

       94
       94
        
               example = ["127.0.0.1"];

     

       95
       95
        
               type = types.listOf types.str;

     

       96
       96
       -
               description = "

     

       96
       96
       +
               description = lib.mdDoc ''

     

       97
       97
        
                 Extra IP's to bind.

     

       98
       98
       -
               ";

     

       98
       98
       +
               '';

     

       99
       99
        
             };

     

       100
       100
        
       

     

       101
       101
        
             extraPort = mkOption {

     

       102
       102
        
               default = "7117";

     

       103
       103
        
               type = types.str;

     

       104
       104
       -
               description = "

     

       104
       104
       +
               description = lib.mdDoc ''

     

       105
       105
        
                 Extra port to avoid filtering.

     

       106
       106
       -
               ";

     

       106
       106
       +
               '';

     

       107
       107
        
             };

     

       108
       108
        
       

     

       109
       109
        
           };

+1 -1

nixos/modules/services/networking/iscsi/root-initiator.nix

···

       77
       77
        
           };

     

       78
       78
        
       

     

       79
       79
        
           extraConfigFile = mkOption {

     

       80
       80
       -
             description = ''

     

       80
       80
       +
             description = lib.mdDoc ''

     

       81
       81
        
               Append an additional file's contents to `/etc/iscsid.conf`. Use a non-store path

     

       82
       82
        
               and store passwords in this file. Note: the file specified here must be available

     

       83
       83
        
               in the initrd, see: `boot.initrd.secrets`.

+2 -2

nixos/modules/services/networking/kresd.nix

···

       59
       59
        
           };

     

       60
       60
        
           package = mkOption {

     

       61
       61
        
             type = types.package;

     

       62
       62
       -
             description = "

     

       62
       62
       +
             description = lib.mdDoc ''

     

       63
       63
        
               knot-resolver package to use.

     

       64
       64
       -
             ";

     

       64
       64
       +
             '';

     

       65
       65
        
             default = pkgs.knot-resolver;

     

       66
       66
        
             defaultText = literalExpression "pkgs.knot-resolver";

     

       67
       67
        
             example = literalExpression "pkgs.knot-resolver.override { extraFeatures = true; }";

+1 -1

nixos/modules/services/networking/lokinet.nix

···

       95
       95
        
                 network.exit-node = [ "example.loki" "example2.loki" ];

     

       96
       96
        
               }

     

       97
       97
        
             '';

     

       98
       98
       -
             description = ''

     

       98
       98
       +
             description = lib.mdDoc ''

     

       99
       99
        
               Configuration for Lokinet.

     

       100
       100
        
               Currently, the best way to view the available settings is by

     

       101
       101
        
               generating a config file using `lokinet -g`.

+1 -1

nixos/modules/services/networking/monero.nix

···

       181
       181
        
             exclusiveNodes = mkOption {

     

       182
       182
        
               type = types.listOf types.str;

     

       183
       183
        
               default = [ ];

     

       184
       184
       -
               description = ''

     

       184
       184
       +
               description = lib.mdDoc ''

     

       185
       185
        
                 List of peer IP addresses to connect to *only*.

     

       186
       186
        
                 If given the other peer options will be ignored.

     

       187
       187
        
               '';

+1 -1

nixos/modules/services/networking/murmur.nix

···

       219
       219
        
             registerHostname = mkOption {

     

       220
       220
        
               type = types.str;

     

       221
       221
        
               default = "";

     

       222
       222
       -
               description = ''

     

       222
       222
       +
               description = lib.mdDoc ''

     

       223
       223
        
                 DNS hostname where your server can be reached. This is only

     

       224
       224
        
                 needed if you want your server to be accessed by its

     

       225
       225
        
                 hostname and not IP - but the name *must* resolve on the

+2 -2

nixos/modules/services/networking/mxisd.nix

···

       49
       49
        
             environmentFile = mkOption {

     

       50
       50
        
               type = types.nullOr types.str;

     

       51
       51
        
               default = null;

     

       52
       52
       -
               description = ''

     

       52
       52
       +
               description = lib.mdDoc ''

     

       53
       53
        
                 Path to an environment-file which may contain secrets to be

     

       54
       54
       -
                 substituted via <package>envsubst</package>.

     

       54
       54
       +
                 substituted via `envsubst`.

     

       55
       55
        
               '';

     

       56
       56
        
             };

     

       57
       57

+1 -1

nixos/modules/services/networking/nar-serve.nix

···

       23
       23
        
             cacheURL = mkOption {

     

       24
       24
        
               type = types.str;

     

       25
       25
        
               default = "https://cache.nixos.org/";

     

       26
       26
       -
               description = ''

     

       26
       26
       +
               description = lib.mdDoc ''

     

       27
       27
        
                 Binary cache URL to connect to.

     

       28
       28
        
       

     

       29
       29
        
                 The URL format is compatible with the nix remote url style, such as:

+2 -2

nixos/modules/services/networking/ncdns.nix

···

       126
       126
        
               description = ''

     

       127
       127
        
                 Path to the file containing the KSK public key.

     

       128
       128
        
                 The key can be generated using the <literal>dnssec-keygen</literal>

     

       129
       129
       -
                 command, provided by the package <package>bind</package> as follows:

     

       129
       129
       +
                 command, provided by the package <literal>bind</literal> as follows:

     

       130
       130
        
                 <programlisting>

     

       131
       131
        
                 $ dnssec-keygen -a RSASHA256 -3 -b 2048 -f KSK bit

     

       132
       132
        
                 </programlisting>

     
···

       147
       147
        
               description = ''

     

       148
       148
        
                 Path to the file containing the ZSK public key.

     

       149
       149
        
                 The key can be generated using the <literal>dnssec-keygen</literal>

     

       150
       150
       -
                 command, provided by the package <package>bind</package> as follows:

     

       150
       150
       +
                 command, provided by the package <literal>bind</literal> as follows:

     

       151
       151
        
                 <programlisting>

     

       152
       152
        
                 $ dnssec-keygen -a RSASHA256 -3 -b 2048 bit

     

       153
       153
        
                 </programlisting>

+2 -2

nixos/modules/services/networking/nix-serve.nix

···

       39
       39
        
                 The path to the file used for signing derivation data.

     

       40
       40
        
                 Generate with:

     

       41
       41
        
       

     

       42
       42
       -
                 ```

     

       42
       42
       +
                 <programlisting>

     

       43
       43
        
                 nix-store --generate-binary-cache-key key-name secret-key-file public-key-file

     

       44
       44
       -
                 ```

     

       44
       44
       +
                 </programlisting>

     

       45
       45
        
       

     

       46
       46
        
                 For more details see <citerefentry><refentrytitle>nix-store</refentrytitle><manvolnum>1</manvolnum></citerefentry>.

     

       47
       47
        
               '';

+1 -1

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

···

       40
       40
        
             dnsmasq = mkOption {

     

       41
       41
        
               type = types.bool;

     

       42
       42
        
               default = true;

     

       43
       43
       -
               description = ''

     

       43
       43
       +
               description = lib.mdDoc ''

     

       44
       44
        
                 Enable dnsmasq forwarding to nixops-dns. This allows to use

     

       45
       45
        
                 nixops-dns for `services.nixops-dns.domain` resolution

     

       46
       46
        
                 while forwarding the rest of the queries to original resolvers.

+1 -1

nixos/modules/services/networking/ocserv.nix

···

       15
       15
        
           config = mkOption {

     

       16
       16
        
             type = types.lines;

     

       17
       17
        
       

     

       18
       18
       -
             description = ''

     

       18
       18
       +
             description = lib.mdDoc ''

     

       19
       19
        
               Configuration content to start an OCServ server.

     

       20
       20
        
       

     

       21
       21
        
               For a full configuration reference,please refer to the online documentation

+2 -2

nixos/modules/services/networking/redsocks.nix

···

       30
       30
        
               type = types.str;

     

       31
       31
        
               default = "stderr";

     

       32
       32
        
               description =

     

       33
       33
       -
                 ''

     

       33
       33
       +
                 lib.mdDoc ''

     

       34
       34
        
                   Where to send logs.

     

       35
       35
        
       

     

       36
       36
        
                   Possible values are:

     
···

       122
       122
        
                                       "Forwarded_ipport" ];

     

       123
       123
        
                   default = "false";

     

       124
       124
        
                   description =

     

       125
       125
       -
                     ''

     

       125
       125
       +
                     lib.mdDoc ''

     

       126
       126
        
                       Way to disclose client IP to the proxy.

     

       127
       127
        
                         - "false": do not disclose

     

       128
       128
        
                       http-connect supports the following ways:

+9 -9

nixos/modules/services/networking/resilio.nix

···

       199
       199
        
                     ];

     

       200
       200
        
                   }

     

       201
       201
        
                 ];

     

       202
       202
       -
               description = ''

     

       202
       202
       +
               description = lib.mdDoc ''

     

       203
       203
        
                 Shared folder list. If enabled, web UI must be

     

       204
       204
       -
                 disabled. Secrets can be generated using <literal>rslsync

     

       205
       205
       -
                 --generate-secret</literal>. Note that this secret will be

     

       204
       204
       +
                 disabled. Secrets can be generated using `rslsync --generate-secret`.

     

       205
       205
       +
                 Note that this secret will be

     

       206
       206
        
                 put inside the Nix store, so it is realistically not very

     

       207
       207
        
                 secret.

     

       208
       208
        
       

     

       209
       209
        
                 If you would like to be able to modify the contents of this

     

       210
       210
        
                 directories, it is recommended that you make your user a

     

       211
       211
       -
                 member of the <literal>rslsync</literal> group.

     

       211
       211
       +
                 member of the `rslsync` group.

     

       212
       212
        
       

     

       213
       213
        
                 Directories in this list should be in the

     

       214
       214
       -
                 <literal>rslsync</literal> group, and that group must have

     

       214
       214
       +
                 `rslsync` group, and that group must have

     

       215
       215
        
                 write access to the directory. It is also recommended that

     

       216
       216
       -
                 <literal>chmod g+s</literal> is applied to the directory

     

       216
       216
       +
                 `chmod g+s` is applied to the directory

     

       217
       217
        
                 so that any sub directories created will also belong to

     

       218
       218
       -
                 the <literal>rslsync</literal> group. Also,

     

       219
       219
       -
                 <literal>setfacl -d -m group:rslsync:rwx</literal> and

     

       220
       220
       -
                 <literal>setfacl -m group:rslsync:rwx</literal> should also

     

       218
       218
       +
                 the `rslsync` group. Also,

     

       219
       219
       +
                 `setfacl -d -m group:rslsync:rwx` and

     

       220
       220
       +
                 `setfacl -m group:rslsync:rwx` should also

     

       221
       221
        
                 be applied so that the sub directories are writable by

     

       222
       222
        
                 the group.

     

       223
       223
        
               '';

+1 -1

nixos/modules/services/networking/rpcbind.nix

···

       13
       13
        
             enable = mkOption {

     

       14
       14
        
               type = types.bool;

     

       15
       15
        
               default = false;

     

       16
       16
       -
               description = ''

     

       16
       16
       +
               description = lib.mdDoc ''

     

       17
       17
        
                 Whether to enable `rpcbind', an ONC RPC directory service

     

       18
       18
        
                 notably used by NFS and NIS, and which can be queried

     

       19
       19
        
                 using the rpcinfo(1) command. `rpcbind` is a replacement for

+2 -2

nixos/modules/services/networking/v2ray.nix

···

       51
       51
        
                   protocol = "freedom";

     

       52
       52
        
                 }];

     

       53
       53
        
               };

     

       54
       54
       -
               description = ''

     

       54
       54
       +
               description = lib.mdDoc ''

     

       55
       55
        
                 The configuration object.

     

       56
       56
        
       

     

       57
       57
        
                 Either `configFile` or `config` must be specified.

     

       58
       58
        
       

     

       59
       59
       -
                 See <link xlink:href="https://www.v2fly.org/en_US/config/overview.html"/>.

     

       59
       59
       +
                 See <https://www.v2fly.org/en_US/config/overview.html>.

     

       60
       60
        
               '';

     

       61
       61
        
             };

     

       62
       62
        
           };

+2 -2

nixos/modules/services/networking/wpa_supplicant.nix

···

       189
       189
        
             allowAuxiliaryImperativeNetworks = mkEnableOption "support for imperative & declarative networks" // {

     

       190
       190
        
               description = ''

     

       191
       191
        
                 Whether to allow configuring networks "imperatively" (e.g. via

     

       192
       192
       -
                 <package>wpa_supplicant_gui</package>) and declaratively via

     

       192
       192
       +
                 <literal>wpa_supplicant_gui</literal>) and declaratively via

     

       193
       193
        
                 <xref linkend="opt-networking.wireless.networks"/>.

     

       194
       194
        
       

     

       195
       195
       -
                 Please note that this adds a custom patch to <package>wpa_supplicant</package>.

     

       195
       195
       +
                 Please note that this adds a custom patch to <literal>wpa_supplicant</literal>.

     

       196
       196
        
               '';

     

       197
       197
        
             };

     

       198
       198

+1 -1

nixos/modules/services/networking/x2goserver.nix

···

       50
       50
        
           settings = mkOption {

     

       51
       51
        
             type = types.attrsOf types.attrs;

     

       52
       52
        
             default = {};

     

       53
       53
       -
             description = ''

     

       53
       53
       +
             description = lib.mdDoc ''

     

       54
       54
        
               x2goserver.conf ini configuration as nix attributes. See

     

       55
       55
        
               `x2goserver.conf(5)` for details

     

       56
       56
        
             '';

+9 -10

nixos/modules/services/networking/yggdrasil.nix

···

       31
       31
        
                   "tcp://0.0.0.0:xxxxx"

     

       32
       32
        
                 ];

     

       33
       33
        
               };

     

       34
       34
       -
               description = ''

     

       34
       34
       +
               description = lib.mdDoc ''

     

       35
       35
        
                 Configuration for yggdrasil, as a Nix attribute set.

     

       36
       36
        
       

     

       37
       37
        
                 Warning: this is stored in the WORLD-READABLE Nix store!

     

       38
       38
        
                 Therefore, it is not appropriate for private keys. If you

     

       39
       39
       -
                 wish to specify the keys, use <option>configFile</option>.

     

       39
       39
       +
                 wish to specify the keys, use {option}`configFile`.

     

       40
       40
        
       

     

       41
       41
       -
                 If the <option>persistentKeys</option> is enabled then the

     

       41
       41
       +
                 If the {option}`persistentKeys` is enabled then the

     

       42
       42
        
                 keys that are generated during activation will override

     

       43
       43
       -
                 those in <option>config</option> or

     

       44
       44
       -
                 <option>configFile</option>.

     

       43
       43
       +
                 those in {option}`config` or

     

       44
       44
       +
                 {option}`configFile`.

     

       45
       45
        
       

     

       46
       46
        
                 If no keys are specified then ephemeral keys are generated

     

       47
       47
        
                 and the Yggdrasil interface will have a random IPv6 address

     

       48
       48
        
                 each time the service is started, this is the default.

     

       49
       49
        
       

     

       50
       50
       -
                 If both <option>configFile</option> and <option>config</option>

     

       50
       50
       +
                 If both {option}`configFile` and {option}`config`

     

       51
       51
        
                 are supplied, they will be combined, with values from

     

       52
       52
       -
                 <option>configFile</option> taking precedence.

     

       52
       52
       +
                 {option}`configFile` taking precedence.

     

       53
       53
        
       

     

       54
       54
       -
                 You can use the command <literal>nix-shell -p yggdrasil --run

     

       55
       55
       -
                 "yggdrasil -genconf"</literal> to generate default

     

       56
       56
       -
                 configuration values with documentation.

     

       54
       54
       +
                 You can use the command `nix-shell -p yggdrasil --run "yggdrasil -genconf"`

     

       55
       55
       +
                 to generate default configuration values with documentation.

     

       57
       56
        
               '';

     

       58
       57
        
             };

     

       59
       58

+4 -4

nixos/modules/services/networking/znc/options.nix

···

       118
       118
        
                 type = types.listOf types.str;

     

       119
       119
        
                 default = [ "webadmin" "adminlog" ];

     

       120
       120
        
                 example = [ "partyline" "webadmin" "adminlog" "log" ];

     

       121
       121
       -
                 description = ''

     

       121
       121
       +
                 description = lib.mdDoc ''

     

       122
       122
        
                   A list of modules to include in the `znc.conf` file.

     

       123
       123
        
                 '';

     

       124
       124
        
               };

     
···

       127
       127
        
                 type = types.listOf types.str;

     

       128
       128
        
                 default = [ "chansaver" "controlpanel" ];

     

       129
       129
        
                 example = [ "chansaver" "controlpanel" "fish" "push" ];

     

       130
       130
       -
                 description = ''

     

       130
       130
       +
                 description = lib.mdDoc ''

     

       131
       131
        
                   A list of user modules to include in the `znc.conf` file.

     

       132
       132
        
                 '';

     

       133
       133
        
               };

     
···

       178
       178
        
                 '';

     

       179
       179
        
                 type = types.str;

     

       180
       180
        
                 description = ''

     

       181
       181
       -
                   Generate with `nix-shell -p znc --command "znc --makepass"`.

     

       181
       181
       +
                   Generate with <command>nix-shell -p znc --command "znc --makepass"</command>.

     

       182
       182
        
                   This is the password used to log in to the ZNC web admin interface.

     

       183
       183
        
                   You can also set this through

     

       184
       184
        
                   <option>services.znc.config.User.&lt;username&gt;.Pass.Method</option>

     
···

       216
       216
        
               extraZncConf = mkOption {

     

       217
       217
        
                 default = "";

     

       218
       218
        
                 type = types.lines;

     

       219
       219
       -
                 description = ''

     

       219
       219
       +
                 description = lib.mdDoc ''

     

       220
       220
        
                   Extra config to `znc.conf` file.

     

       221
       221
        
                 '';

     

       222
       222
        
               };

+1 -1

nixos/modules/services/search/meilisearch.nix

···

       68
       68
        
           };

     

       69
       69
        
       

     

       70
       70
        
           logLevel = mkOption {

     

       71
       71
       -
             description = ''

     

       71
       71
       +
             description = lib.mdDoc ''

     

       72
       72
        
               Defines how much detail should be present in MeiliSearch's logs.

     

       73
       73
        
               MeiliSearch currently supports four log levels, listed in order of increasing verbosity:

     

       74
       74
        
               - 'ERROR': only log unexpected events indicating MeiliSearch is not functioning as expected

+1 -1

nixos/modules/services/security/fail2ban.nix

···

       73
       73
        
               default = [];

     

       74
       74
        
               type = types.listOf types.package;

     

       75
       75
        
               example = lib.literalExpression "[ pkgs.ipset ]";

     

       76
       76
       -
               description = ''

     

       76
       76
       +
               description = lib.mdDoc ''

     

       77
       77
        
                 Extra packages to be made available to the fail2ban service. The example contains

     

       78
       78
        
                 the packages needed by the `iptables-ipset-proto6` action.

     

       79
       79
        
               '';

+2 -2

nixos/modules/services/security/haka.nix

···

       61
       61
        
               default = pkgs.haka;

     

       62
       62
        
               defaultText = literalExpression "pkgs.haka";

     

       63
       63
        
               type = types.package;

     

       64
       64
       -
               description = "

     

       64
       64
       +
               description = lib.mdDoc ''

     

       65
       65
        
                 Which Haka derivation to use.

     

       66
       66
       -
               ";

     

       66
       66
       +
               '';

     

       67
       67
        
             };

     

       68
       68
        
       

     

       69
       69
        
             configFile = mkOption {

+1 -1

nixos/modules/services/security/infnoise.nix

···

       10
       10
        
             enable = mkEnableOption "the Infinite Noise TRNG driver";

     

       11
       11
        
       

     

       12
       12
        
             fillDevRandom = mkOption {

     

       13
       13
       -
               description = ''

     

       13
       13
       +
               description = lib.mdDoc ''

     

       14
       14
        
                 Whether to run the infnoise driver as a daemon to refill /dev/random.

     

       15
       15
        
       

     

       16
       16
        
                 If disabled, you can use the `infnoise` command-line tool to

+3 -3

nixos/modules/services/security/oauth2_proxy.nix

···

       160
       160
        
             domains = mkOption {

     

       161
       161
        
               type = types.listOf types.str;

     

       162
       162
        
               default = [];

     

       163
       163
       -
               description = ''

     

       163
       163
       +
               description = lib.mdDoc ''

     

       164
       164
        
                 Authenticate emails with the specified domains. Use

     

       165
       165
       -
                 <literal>*</literal> to authenticate any email.

     

       165
       165
       +
                 `*` to authenticate any email.

     

       166
       166
        
               '';

     

       167
       167
        
             };

     

       168
       168
        
       

     
···

       347
       347
        
             domain = mkOption {

     

       348
       348
        
               type = types.nullOr types.str;

     

       349
       349
        
               default = null;

     

       350
       350
       -
               description = ''

     

       350
       350
       +
               description = lib.mdDoc ''

     

       351
       351
        
                 Optional cookie domains to force cookies to (ie: `.yourcompany.com`).

     

       352
       352
        
                 The longest domain matching the request's host will be used (or the shortest

     

       353
       353
        
                 cookie domain if there is no match).

+5 -5

nixos/modules/services/security/privacyidea.nix

···

       75
       75
        
               description = ''

     

       76
       76
        
                 File to load as environment file. Environment variables

     

       77
       77
        
                 from this file will be interpolated into the config file

     

       78
       78
       -
                 using <package>envsubst</package> which is helpful for specifying

     

       78
       78
       +
                 using <literal>envsubst</literal> which is helpful for specifying

     

       79
       79
        
                 secrets:

     

       80
       80
        
                 <programlisting>

     

       81
       81
        
                 { <xref linkend="opt-services.privacyidea.secretKey"/> = "$SECRET"; }

     
···

       204
       204
        
               settings = mkOption {

     

       205
       205
        
                 type = with types; attrsOf (attrsOf (oneOf [ str bool int (listOf str) ]));

     

       206
       206
        
                 default = {};

     

       207
       207
       -
                 description = ''

     

       208
       208
       -
                   Attribute-set containing the settings for <package>privacyidea-ldap-proxy</package>.

     

       207
       207
       +
                 description = lib.mdDoc ''

     

       208
       208
       +
                   Attribute-set containing the settings for `privacyidea-ldap-proxy`.

     

       209
       209
        
                   It's possible to pass secrets using env-vars as substitutes and

     

       210
       210
       -
                   use the option <xref linkend="opt-services.privacyidea.ldap-proxy.environmentFile"/>

     

       211
       211
       -
                   to inject them via <package>envsubst</package>.

     

       210
       210
       +
                   use the option [](#opt-services.privacyidea.ldap-proxy.environmentFile)

     

       211
       211
       +
                   to inject them via `envsubst`.

     

       212
       212
        
                 '';

     

       213
       213
        
               };

     

       214
       214

+2 -2

nixos/modules/services/system/cloud-init.nix

···

       39
       39
        
             btrfs.enable = mkOption {

     

       40
       40
        
               type = types.bool;

     

       41
       41
        
               default = false;

     

       42
       42
       -
               description = ''

     

       42
       42
       +
               description = lib.mdDoc ''

     

       43
       43
        
                 Allow the cloud-init service to operate `btrfs` filesystem.

     

       44
       44
        
               '';

     

       45
       45
        
             };

     
···

       47
       47
        
             ext4.enable = mkOption {

     

       48
       48
        
               type = types.bool;

     

       49
       49
        
               default = true;

     

       50
       50
       -
               description = ''

     

       50
       50
       +
               description = lib.mdDoc ''

     

       51
       51
        
                 Allow the cloud-init service to operate `ext4` filesystem.

     

       52
       52
        
               '';

     

       53
       53
        
             };

+6 -6

nixos/modules/services/system/self-deploy.nix

···

       41
       41
        
       

     

       42
       42
        
             default = null;

     

       43
       43
        
       

     

       44
       44
       -
             description = ''

     

       44
       44
       +
             description = lib.mdDoc ''

     

       45
       45
        
               Attribute of `nixFile` that builds the current system.

     

       46
       46
        
             '';

     

       47
       47
        
           };

     
···

       51
       51
        
       

     

       52
       52
        
             default = { };

     

       53
       53
        
       

     

       54
       54
       -
             description = ''

     

       54
       54
       +
             description = lib.mdDoc ''

     

       55
       55
        
               Arguments to `nix-build` passed as `--argstr` or `--arg` depending on

     

       56
       56
        
               the type.

     

       57
       57
        
             '';

     
···

       62
       62
        
       

     

       63
       63
        
             default = "switch";

     

       64
       64
        
       

     

       65
       65
       -
             description = ''

     

       65
       65
       +
             description = lib.mdDoc ''

     

       66
       66
        
               The `switch-to-configuration` subcommand used.

     

       67
       67
        
             '';

     

       68
       68
        
           };

     
···

       70
       70
        
           repository = lib.mkOption {

     

       71
       71
        
             type = with lib.types; oneOf [ path str ];

     

       72
       72
        
       

     

       73
       73
       -
             description = ''

     

       73
       73
       +
             description = lib.mdDoc ''

     

       74
       74
        
               The repository to fetch from. Must be properly formatted for git.

     

       75
       75
        
       

     

       76
       76
        
               If this value is set to a path (must begin with `/`) then it's

     
···

       99
       99
        
       

     

       100
       100
        
             default = "master";

     

       101
       101
        
       

     

       102
       102
       -
             description = ''

     

       102
       102
       +
             description = lib.mdDoc ''

     

       103
       103
        
               Branch to track

     

       104
       104
        
       

     

       105
       105
        
               Technically speaking any ref can be specified here, as this is

     
···

       113
       113
        
       

     

       114
       114
        
             default = "hourly";

     

       115
       115
        
       

     

       116
       116
       -
             description = ''

     

       116
       116
       +
             description = lib.mdDoc ''

     

       117
       117
        
               The schedule on which to run the `self-deploy` service. Format

     

       118
       118
        
               specified by `systemd.time 7`.

     

       119
       119

+5 -5

nixos/modules/services/torrent/magnetico.nix

···

       124
       124
        
               Usernames must start with a lowercase ([a-z]) ASCII character, might

     

       125
       125
        
               contain non-consecutive underscores except at the end, and consists of

     

       126
       126
        
               small-case a-z characters and digits 0-9.  The

     

       127
       127
       -
               <command>htpasswd</command> tool from the <package>apacheHttpd

     

       128
       128
       -
               </package> package may be used to generate the hash: <command>htpasswd

     

       129
       129
       -
               -bnBC 12 username password</command>

     

       127
       127
       +
               <command>htpasswd</command> tool from the <literal>apacheHttpd</literal>

     

       128
       128
       +
               package may be used to generate the hash:

     

       129
       129
       +
               <command>htpasswd -bnBC 12 username password</command>

     

       130
       130
        
       

     

       131
       131
        
               <warning>

     

       132
       132
        
               <para>

     
···

       150
       150
        
               start with a lowecase ([a-z]) ASCII character, might contain

     

       151
       151
        
               non-consecutive underscores except at the end, and consists of

     

       152
       152
        
               small-case a-z characters and digits 0-9.

     

       153
       153
       -
               The <command>htpasswd</command> tool from the <package>apacheHttpd

     

       154
       154
       -
               </package> package may be used to generate the hash:

     

       153
       153
       +
               The <command>htpasswd</command> tool from the <literal>apacheHttpd</literal>

     

       154
       154
       +
               package may be used to generate the hash:

     

       155
       155
        
               <command>htpasswd -bnBC 12 username password</command>

     

       156
       156
        
             '';

     

       157
       157
        
           };

+10 -13

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

···

       121
       121
        
                   max_reqs_per_ip_mode = "warn+block";

     

       122
       122
        
                 };

     

       123
       123
        
               '';

     

       124
       124
       -
               description = ''

     

       124
       124
       +
               description = lib.mdDoc ''

     

       125
       125
        
                 Additional settings to put in the

     

       126
       126
       -
                 <filename>discourse.conf</filename> file.

     

       126
       126
       +
                 {file}`discourse.conf` file.

     

       127
       127
        
       

     

       128
       128
        
                 Look in the

     

       129
       129
       -
                 <link xlink:href="https://github.com/discourse/discourse/blob/master/config/discourse_defaults.conf">discourse_defaults.conf</link>

     

       129
       129
       +
                 [discourse_defaults.conf](https://github.com/discourse/discourse/blob/master/config/discourse_defaults.conf)

     

       130
       130
        
                 file in the upstream distribution to find available options.

     

       131
       131
        
       

     

       132
       132
       -
                 Setting an option to <literal>null</literal> means

     

       133
       133
       -
                 <quote>define variable, but leave right-hand side

     

       134
       134
       -
                 empty</quote>.

     

       132
       132
       +
                 Setting an option to `null` means

     

       133
       133
       +
                 “define variable, but leave right-hand side empty”.

     

       135
       134
        
               '';

     

       136
       135
        
             };

     

       137
       136
        
       

     
···

       241
       240
        
               host = lib.mkOption {

     

       242
       241
        
                 type = with lib.types; nullOr str;

     

       243
       242
        
                 default = null;

     

       244
       244
       -
                 description = ''

     

       245
       245
       -
                   Discourse database hostname. <literal>null</literal> means <quote>prefer

     

       246
       246
       -
                   local unix socket connection</quote>.

     

       243
       243
       +
                 description = lib.mdDoc ''

     

       244
       244
       +
                   Discourse database hostname. `null` means

     

       245
       245
       +
                   “prefer local unix socket connection”.

     

       247
       246
        
                 '';

     

       248
       247
        
               };

     

       249
       248
        
       

     
···

       494
       493
        
                   discourse-github

     

       495
       494
        
                 ];

     

       496
       495
        
               '';

     

       497
       497
       -
               description = ''

     

       498
       498
       -
                 Plugins to install as part of

     

       499
       499
       -
                 <productname>Discourse</productname>, expressed as a list of

     

       500
       500
       -
                 derivations.

     

       496
       496
       +
               description = lib.mdDoc ''

     

       497
       497
       +
                 Plugins to install as part of Discourse, expressed as a list of derivations.

     

       501
       498
        
               '';

     

       502
       499
        
             };

     

       503
       500

+9 -9

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

···

       189
       189
        
             allowAnonymousEdits = mkOption {

     

       190
       190
        
               type = types.bool;

     

       191
       191
        
               default = false;

     

       192
       192
       -
               description = ''

     

       193
       193
       -
                 Whether to allow guests to edit existing notes with the `freely' permission,

     

       194
       194
       -
                 when <option>allowAnonymous</option> is enabled.

     

       192
       192
       +
               description = lib.mdDoc ''

     

       193
       193
       +
                 Whether to allow guests to edit existing notes with the `freely` permission,

     

       194
       194
       +
                 when {option}`allowAnonymous` is enabled.

     

       195
       195
        
               '';

     

       196
       196
        
             };

     

       197
       197
        
             allowFreeURL = mkOption {

     
···

       937
       937
        
                     id = mkOption {

     

       938
       938
        
                       type = types.str;

     

       939
       939
        
                       default = "";

     

       940
       940
       -
                       description = ''

     

       940
       940
       +
                       description = lib.mdDoc ''

     

       941
       941
        
                         Attribute map for `id'.

     

       942
       942
        
                         Defaults to `NameID' of SAML response.

     

       943
       943
        
                       '';

     
···

       945
       945
        
                     username = mkOption {

     

       946
       946
        
                       type = types.str;

     

       947
       947
        
                       default = "";

     

       948
       948
       -
                       description = ''

     

       948
       948
       +
                       description = lib.mdDoc ''

     

       949
       949
        
                         Attribute map for `username'.

     

       950
       950
        
                         Defaults to `NameID' of SAML response.

     

       951
       951
        
                       '';

     
···

       953
       953
        
                     email = mkOption {

     

       954
       954
        
                       type = types.str;

     

       955
       955
        
                       default = "";

     

       956
       956
       -
                       description = ''

     

       957
       957
       -
                         Attribute map for `email'.

     

       958
       958
       -
                         Defaults to `NameID' of SAML response if

     

       959
       959
       -
                         <option>identifierFormat</option> has

     

       956
       956
       +
                       description = lib.mdDoc ''

     

       957
       957
       +
                         Attribute map for `email`.

     

       958
       958
       +
                         Defaults to `NameID` of SAML response if

     

       959
       959
       +
                         {option}`identifierFormat` has

     

       960
       960
        
                         the default value.

     

       961
       961
        
                       '';

     

       962
       962
        
                     };

+3 -3

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

···

       246
       246
        
           nginx.enable = lib.mkOption {

     

       247
       247
        
             type = types.bool;

     

       248
       248
        
             default = false;

     

       249
       249
       -
             description = ''

     

       249
       249
       +
             description = lib.mdDoc ''

     

       250
       250
        
               Whether to configure nginx as a reverse proxy for Invidious.

     

       251
       251
        
       

     

       252
       252
       -
               It serves it under the domain specified in <option>services.invidious.settings.domain</option> with enabled TLS and ACME.

     

       253
       253
       -
               Further configuration can be done through <option>services.nginx.virtualHosts.''${config.services.invidious.settings.domain}.*</option>,

     

       252
       252
       +
               It serves it under the domain specified in {option}`services.invidious.settings.domain` with enabled TLS and ACME.

     

       253
       253
       +
               Further configuration can be done through {option}`services.nginx.virtualHosts.''${config.services.invidious.settings.domain}.*`,

     

       254
       254
        
               which can also be used to disable AMCE and TLS.

     

       255
       255
        
             '';

     

       256
       256
        
           };

+3 -3

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

···

       20
       20
        
             '';

     

       21
       21
        
       

     

       22
       22
        
             settings = mkOption {

     

       23
       23
       -
               description = ''

     

       24
       24
       -
                 Configuration for <package>isso</package>.

     

       23
       23
       +
               description = lib.mdDoc ''

     

       24
       24
       +
                 Configuration for `isso`.

     

       25
       25
        
       

     

       26
       26
       -
                 See <link xlink:href="https://posativ.org/isso/docs/configuration/server/">Isso Server Configuration</link>

     

       26
       26
       +
                 See [Isso Server Configuration](https://posativ.org/isso/docs/configuration/server/)

     

       27
       27
        
                 for supported values.

     

       28
       28
        
               '';

     

       29
       29

+6 -6

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

···

       130
       130
        
             };

     

       131
       131
        
       

     

       132
       132
        
             user = lib.mkOption {

     

       133
       133
       -
               description = ''

     

       133
       133
       +
               description = lib.mdDoc ''

     

       134
       134
        
                 User under which mastodon runs. If it is set to "mastodon",

     

       135
       135
        
                 that user will be created, otherwise it should be set to the

     

       136
       136
        
                 name of a user created elsewhere.  In both cases,

     

       137
       137
       -
                 <package>mastodon</package> and a package containing only

     

       138
       138
       -
                 the shell script <literal>mastodon-env</literal> will be added to

     

       137
       137
       +
                 `mastodon` and a package containing only

     

       138
       138
       +
                 the shell script `mastodon-env` will be added to

     

       139
       139
        
                 the user's package set. To run a command from

     

       140
       140
       -
                 <package>mastodon</package> such as <literal>tootctl</literal>

     

       140
       140
       +
                 `mastodon` such as `tootctl`

     

       141
       141
        
                 with the environment configured by this module use

     

       142
       142
       -
                 <literal>mastodon-env</literal>, as in:

     

       142
       142
       +
                 `mastodon-env`, as in:

     

       143
       143
        
       

     

       144
       144
       -
                 <literal>mastodon-env tootctl accounts create newuser --email newuser@example.com</literal>

     

       144
       144
       +
                 `mastodon-env tootctl accounts create newuser --email newuser@example.com`

     

       145
       145
        
               '';

     

       146
       146
        
               type = lib.types.str;

     

       147
       147
        
               default = "mastodon";

+1 -1

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

···

       57
       57
        
                 Name of the web server user that forwards requests to <option>services.phpfpm.pools.&lt;name&gt;.socket</option> the fastcgi socket for Matomo if the nginx

     

       58
       58
        
                 option is not used. Either this option or the nginx option is mandatory.

     

       59
       59
        
                 If you want to use another webserver than nginx, you need to set this to that server's user

     

       60
       60
       -
                 and pass fastcgi requests to `index.php`, `matomo.php` and `piwik.php` (legacy name) to this socket.

     

       60
       60
       +
                 and pass fastcgi requests to <literal>index.php</literal>, <literal>matomo.php</literal> and <literal>piwik.php</literal> (legacy name) to this socket.

     

       61
       61
        
               '';

     

       62
       62
        
             };

     

       63
       63

+1 -1

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

···

       138
       138
        
             createLocally = mkOption {

     

       139
       139
        
               type = types.bool;

     

       140
       140
        
               default = true;

     

       141
       141
       -
               description = "Create the database and database user locally.";

     

       141
       141
       +
               description = lib.mdDoc "Create the database and database user locally.";

     

       142
       142
        
             };

     

       143
       143
        
           };

     

       144
       144

+4 -4

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

···

       532
       532
        
               here because it has the side-effect that personal information is even accessible to

     

       533
       533
        
               unauthenticated users by default.

     

       534
       534
        
       

     

       535
       535
       -
               By default, the following properties are set to <quote>Show to everyone</quote>

     

       535
       535
       +
               By default, the following properties are set to “Show to everyone”

     

       536
       536
        
               if this flag is enabled:

     

       537
       537
        
               <itemizedlist>

     

       538
       538
        
               <listitem><para>About</para></listitem>

     
···

       569
       569
        
           secretFile = mkOption {

     

       570
       570
        
             type = types.nullOr types.str;

     

       571
       571
        
             default = null;

     

       572
       572
       -
             description = ''

     

       572
       572
       +
             description = lib.mdDoc ''

     

       573
       573
        
               Secret options which will be appended to nextcloud's config.php file (written as JSON, in the same

     

       574
       574
       -
               form as the <xref linkend="opt-services.nextcloud.extraOptions"/> option), for example

     

       575
       575
       -
               <programlisting>{"redis":{"password":"secret"}}</programlisting>.

     

       574
       574
       +
               form as the [](#opt-services.nextcloud.extraOptions) option), for example

     

       575
       575
       +
               `{"redis":{"password":"secret"}}`.

     

       576
       576
        
             '';

     

       577
       577
        
           };

     

       578
       578

+1 -1

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

···

       93
       93
        
                 '''

     

       94
       94
        
               '';

     

       95
       95
        
       

     

       96
       96
       -
               description = ''

     

       96
       96
       +
               description = lib.mdDoc ''

     

       97
       97
        
                 Options for the JVM written to `nexus.jvmopts`.

     

       98
       98
        
                 Please refer to the docs (https://help.sonatype.com/repomanager3/installation/configuring-the-runtime-environment)

     

       99
       99
        
                 for further information.

+8 -8

nixos/modules/services/web-apps/pgpkeyserver-lite.nix

···

       24
       24
        
               default = pkgs.pgpkeyserver-lite;

     

       25
       25
        
               defaultText = literalExpression "pkgs.pgpkeyserver-lite";

     

       26
       26
        
               type = types.package;

     

       27
       27
       -
               description = "

     

       27
       27
       +
               description = lib.mdDoc ''

     

       28
       28
        
                 Which webgui derivation to use.

     

       29
       29
       -
               ";

     

       29
       29
       +
               '';

     

       30
       30
        
             };

     

       31
       31
        
       

     

       32
       32
        
             hostname = mkOption {

     

       33
       33
        
               type = types.str;

     

       34
       34
       -
               description = "

     

       34
       34
       +
               description = lib.mdDoc ''

     

       35
       35
        
                 Which hostname to set the vHost to that is proxying to sks.

     

       36
       36
       -
               ";

     

       36
       36
       +
               '';

     

       37
       37
        
             };

     

       38
       38
        
       

     

       39
       39
        
             hkpAddress = mkOption {

     

       40
       40
        
               default = builtins.head sksCfg.hkpAddress;

     

       41
       41
        
               defaultText = literalExpression "head config.${sksOpt.hkpAddress}";

     

       42
       42
        
               type = types.str;

     

       43
       43
       -
               description = "

     

       43
       43
       +
               description = lib.mdDoc ''

     

       44
       44
        
                 Wich ip address the sks-keyserver is listening on.

     

       45
       45
       -
               ";

     

       45
       45
       +
               '';

     

       46
       46
        
             };

     

       47
       47
        
       

     

       48
       48
        
             hkpPort = mkOption {

     

       49
       49
        
               default = sksCfg.hkpPort;

     

       50
       50
        
               defaultText = literalExpression "config.${sksOpt.hkpPort}";

     

       51
       51
        
               type = types.int;

     

       52
       52
       -
               description = "

     

       52
       52
       +
               description = lib.mdDoc ''

     

       53
       53
        
                 Which port the sks-keyserver is listening on.

     

       54
       54
       -
               ";

     

       54
       54
       +
               '';

     

       55
       55
        
             };

     

       56
       56
        
           };

     

       57
       57
        
         };

+4 -4

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

···

       49
       49
        
               url = mkOption {

     

       50
       50
        
                 default = "http://localhost:8123/default";

     

       51
       51
        
                 type = types.str;

     

       52
       52
       -
                 description = ''

     

       53
       53
       -
                   The URL to be used to connect to <package>clickhouse</package>.

     

       52
       52
       +
                 description = lib.mdDoc ''

     

       53
       53
       +
                   The URL to be used to connect to `clickhouse`.

     

       54
       54
        
                 '';

     

       55
       55
        
               };

     

       56
       56
        
             };

     
···

       66
       66
        
               socket = mkOption {

     

       67
       67
        
                 default = "/run/postgresql";

     

       68
       68
        
                 type = types.str;

     

       69
       69
       -
                 description = ''

     

       70
       70
       -
                   Path to the UNIX domain-socket to communicate with <package>postgres</package>.

     

       69
       69
       +
                 description = lib.mdDoc ''

     

       70
       70
       +
                   Path to the UNIX domain-socket to communicate with `postgres`.

     

       71
       71
        
                 '';

     

       72
       72
        
               };

     

       73
       73
        
             };

+2 -2

nixos/modules/services/web-apps/rss-bridge.nix

···

       66
       66
        
                   "Twitter"

     

       67
       67
        
                 ]

     

       68
       68
        
               '';

     

       69
       69
       -
               description = ''

     

       69
       69
       +
               description = lib.mdDoc ''

     

       70
       70
        
                 List of bridges to be whitelisted.

     

       71
       71
        
                 If the list is empty, rss-bridge will use whitelist.default.txt.

     

       72
       72
       -
                 Use <literal>[ "*" ]</literal> to whitelist all.

     

       72
       72
       +
                 Use `[ "*" ]` to whitelist all.

     

       73
       73
        
               '';

     

       74
       74
        
             };

     

       75
       75
        
           };

+4 -4

nixos/modules/services/web-apps/wiki-js.nix

···

       54
       54
        
                   type = mkOption {

     

       55
       55
        
                     default = "postgres";

     

       56
       56
        
                     type = types.enum [ "postgres" "mysql" "mariadb" "mssql" ];

     

       57
       57
       -
                     description = ''

     

       58
       58
       -
                       Database driver to use for persistence. Please note that <literal>sqlite</literal>

     

       57
       57
       +
                     description = lib.mdDoc ''

     

       58
       58
       +
                       Database driver to use for persistence. Please note that `sqlite`

     

       59
       59
        
                       is currently not supported as the build process for it is currently not implemented

     

       60
       60
       -
                       in <package>pkgs.wiki-js</package> and it's not recommended by upstream for

     

       60
       60
       +
                       in `pkgs.wiki-js` and it's not recommended by upstream for

     

       61
       61
        
                       production use.

     

       62
       62
        
                     '';

     

       63
       63
        
                   };

     
···

       94
       94
        
               };

     

       95
       95
        
             };

     

       96
       96
        
             description = ''

     

       97
       97
       -
               Settings to configure <package>wiki-js</package>. This directly

     

       97
       97
       +
               Settings to configure <literal>wiki-js</literal>. This directly

     

       98
       98
        
               corresponds to <link xlink:href="https://docs.requarks.io/install/config">the upstream configuration options</link>.

     

       99
       99
        
       

     

       100
       100
        
               Secrets can be injected via the environment by

+1 -1

nixos/modules/services/web-servers/apache-httpd/location-options.nix

···

       43
       43
        
           priority = mkOption {

     

       44
       44
        
             type = types.int;

     

       45
       45
        
             default = 1000;

     

       46
       46
       -
             description = ''

     

       46
       46
       +
             description = lib.mdDoc ''

     

       47
       47
        
               Order of this location block in relation to the others in the vhost.

     

       48
       48
        
               The semantics are the same as with `lib.mkOrder`. Smaller values have

     

       49
       49
        
               a greater priority.

+1 -1

nixos/modules/services/web-servers/darkhttpd.nix

···

       29
       29
        
           address = mkOption {

     

       30
       30
        
             default = "127.0.0.1";

     

       31
       31
        
             type = str;

     

       32
       32
       -
             description = ''

     

       32
       32
       +
             description = lib.mdDoc ''

     

       33
       33
        
               Address to listen on.

     

       34
       34
        
               Pass `all` to listen on all interfaces.

     

       35
       35
        
             '';

+30 -30

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

···

       390
       390
        
             statusPage = mkOption {

     

       391
       391
        
               default = false;

     

       392
       392
        
               type = types.bool;

     

       393
       393
       -
               description = "

     

       393
       393
       +
               description = lib.mdDoc ''

     

       394
       394
        
                 Enable status page reachable from localhost on http://127.0.0.1/nginx_status.

     

       395
       395
       -
               ";

     

       395
       395
       +
               '';

     

       396
       396
        
             };

     

       397
       397
        
       

     

       398
       398
        
             recommendedTlsSettings = mkOption {

     

       399
       399
        
               default = false;

     

       400
       400
        
               type = types.bool;

     

       401
       401
       -
               description = "

     

       401
       401
       +
               description = lib.mdDoc ''

     

       402
       402
        
                 Enable recommended TLS settings.

     

       403
       403
       -
               ";

     

       403
       403
       +
               '';

     

       404
       404
        
             };

     

       405
       405
        
       

     

       406
       406
        
             recommendedOptimisation = mkOption {

     

       407
       407
        
               default = false;

     

       408
       408
        
               type = types.bool;

     

       409
       409
       -
               description = "

     

       409
       409
       +
               description = lib.mdDoc ''

     

       410
       410
        
                 Enable recommended optimisation settings.

     

       411
       411
       -
               ";

     

       411
       411
       +
               '';

     

       412
       412
        
             };

     

       413
       413
        
       

     

       414
       414
        
             recommendedGzipSettings = mkOption {

     

       415
       415
        
               default = false;

     

       416
       416
        
               type = types.bool;

     

       417
       417
       -
               description = "

     

       417
       417
       +
               description = lib.mdDoc ''

     

       418
       418
        
                 Enable recommended gzip settings.

     

       419
       419
       -
               ";

     

       419
       419
       +
               '';

     

       420
       420
        
             };

     

       421
       421
        
       

     

       422
       422
        
             recommendedProxySettings = mkOption {

     

       423
       423
        
               default = false;

     

       424
       424
        
               type = types.bool;

     

       425
       425
       -
               description = "

     

       425
       425
       +
               description = lib.mdDoc ''

     

       426
       426
        
                 Whether to enable recommended proxy settings if a vhost does not specify the option manually.

     

       427
       427
       -
               ";

     

       427
       427
       +
               '';

     

       428
       428
        
             };

     

       429
       429
        
       

     

       430
       430
        
             proxyTimeout = mkOption {

     

       431
       431
        
               type = types.str;

     

       432
       432
        
               default = "60s";

     

       433
       433
        
               example = "20s";

     

       434
       434
       -
               description = "

     

       434
       434
       +
               description = lib.mdDoc ''

     

       435
       435
        
                 Change the proxy related timeouts in recommendedProxySettings.

     

       436
       436
       -
               ";

     

       436
       436
       +
               '';

     

       437
       437
        
             };

     

       438
       438
        
       

     

       439
       439
        
             defaultListenAddresses = mkOption {

     
···

       441
       441
        
               default = [ "0.0.0.0" ] ++ optional enableIPv6 "[::0]";

     

       442
       442
        
               defaultText = literalExpression ''[ "0.0.0.0" ] ++ lib.optional config.networking.enableIPv6 "[::0]"'';

     

       443
       443
        
               example = literalExpression ''[ "10.0.0.12" "[2002:a00:1::]" ]'';

     

       444
       444
       -
               description = "

     

       444
       444
       +
               description = lib.mdDoc ''

     

       445
       445
        
                 If vhosts do not specify listenAddresses, use these addresses by default.

     

       446
       446
       -
               ";

     

       446
       446
       +
               '';

     

       447
       447
        
             };

     

       448
       448
        
       

     

       449
       449
        
             package = mkOption {

     
···

       453
       453
        
               apply = p: p.override {

     

       454
       454
        
                 modules = p.modules ++ cfg.additionalModules;

     

       455
       455
        
               };

     

       456
       456
       -
               description = "

     

       456
       456
       +
               description = lib.mdDoc ''

     

       457
       457
        
                 Nginx package to use. This defaults to the stable version. Note

     

       458
       458
        
                 that the nginx team recommends to use the mainline version which

     

       459
       459
       -
                 available in nixpkgs as <literal>nginxMainline</literal>.

     

       460
       460
       -
               ";

     

       459
       459
       +
                 available in nixpkgs as `nginxMainline`.

     

       460
       460
       +
               '';

     

       461
       461
        
             };

     

       462
       462
        
       

     

       463
       463
        
             additionalModules = mkOption {

     
···

       474
       474
        
             logError = mkOption {

     

       475
       475
        
               default = "stderr";

     

       476
       476
        
               type = types.str;

     

       477
       477
       -
               description = "

     

       477
       477
       +
               description = lib.mdDoc ''

     

       478
       478
        
                 Configures logging.

     

       479
       479
        
                 The first parameter defines a file that will store the log. The

     

       480
       480
        
                 special value stderr selects the standard error file. Logging to

     
···

       485
       485
        
                 increasing severity. Setting a certain log level will cause all

     

       486
       486
        
                 messages of the specified and more severe log levels to be logged.

     

       487
       487
        
                 If this parameter is omitted then error is used.

     

       488
       488
       -
               ";

     

       488
       488
       +
               '';

     

       489
       489
        
             };

     

       490
       490
        
       

     

       491
       491
        
             preStart =  mkOption {

     

       492
       492
        
               type = types.lines;

     

       493
       493
        
               default = "";

     

       494
       494
       -
               description = "

     

       494
       494
       +
               description = lib.mdDoc ''

     

       495
       495
        
                 Shell commands executed before the service's nginx is started.

     

       496
       496
       -
               ";

     

       496
       496
       +
               '';

     

       497
       497
        
             };

     

       498
       498
        
       

     

       499
       499
        
             config = mkOption {

     
···

       551
       551
        
             httpConfig = mkOption {

     

       552
       552
        
               type = types.lines;

     

       553
       553
        
               default = "";

     

       554
       554
       -
               description = "

     

       554
       554
       +
               description = lib.mdDoc ''

     

       555
       555
        
                 Configuration lines to be set inside the http block.

     

       556
       556
        
                 This is mutually exclusive with the structured configuration

     

       557
       557
        
                 via virtualHosts and the recommendedXyzSettings configuration

     

       558
       558
        
                 options. See appendHttpConfig for appending to the generated http block.

     

       559
       559
       -
               ";

     

       559
       559
       +
               '';

     

       560
       560
        
             };

     

       561
       561
        
       

     

       562
       562
        
             streamConfig = mkOption {

     
···

       569
       569
        
                   proxy_pass 192.168.0.1:53535;

     

       570
       570
        
                 }

     

       571
       571
        
               '';

     

       572
       572
       -
               description = "

     

       572
       572
       +
               description = lib.mdDoc ''

     

       573
       573
        
                 Configuration lines to be set inside the stream block.

     

       574
       574
       -
               ";

     

       574
       574
       +
               '';

     

       575
       575
        
             };

     

       576
       576
        
       

     

       577
       577
        
             eventsConfig = mkOption {

     
···

       585
       585
        
             appendHttpConfig = mkOption {

     

       586
       586
        
               type = types.lines;

     

       587
       587
        
               default = "";

     

       588
       588
       -
               description = "

     

       588
       588
       +
               description = lib.mdDoc ''

     

       589
       589
        
                 Configuration lines to be appended to the generated http block.

     

       590
       590
        
                 This is mutually exclusive with using config and httpConfig for

     

       591
       591
        
                 specifying the whole http block verbatim.

     

       592
       592
       -
               ";

     

       592
       592
       +
               '';

     

       593
       593
        
             };

     

       594
       594
        
       

     

       595
       595
        
             enableReload = mkOption {

     

       596
       596
        
               default = false;

     

       597
       597
        
               type = types.bool;

     

       598
       598
       -
               description = ''

     

       598
       598
       +
               description = lib.mdDoc ''

     

       599
       599
        
                 Reload nginx when configuration file changes (instead of restart).

     

       600
       600
       -
                 The configuration file is exposed at <filename>/etc/nginx/nginx.conf</filename>.

     

       601
       601
       -
                 See also <literal>systemd.services.*.restartIfChanged</literal>.

     

       600
       600
       +
                 The configuration file is exposed at {file}`/etc/nginx/nginx.conf`.

     

       601
       601
       +
                 See also `systemd.services.*.restartIfChanged`.

     

       602
       602
        
               '';

     

       603
       603
        
             };

     

       604
       604

+1 -1

nixos/modules/services/web-servers/nginx/location-options.nix

···

       122
       122
        
           priority = mkOption {

     

       123
       123
        
             type = types.int;

     

       124
       124
        
             default = 1000;

     

       125
       125
       -
             description = ''

     

       125
       125
       +
             description = lib.mdDoc ''

     

       126
       126
        
               Order of this location block in relation to the others in the vhost.

     

       127
       127
        
               The semantics are the same as with `lib.mkOrder`. Smaller values have

     

       128
       128
        
               a greater priority.

+3 -3

nixos/modules/services/web-servers/nginx/vhost-options.nix

···

       197
       197
        
           http3 = mkOption {

     

       198
       198
        
             type = types.bool;

     

       199
       199
        
             default = false;

     

       200
       200
       -
             description = ''

     

       200
       200
       +
             description = lib.mdDoc ''

     

       201
       201
        
               Whether to enable HTTP 3.

     

       202
       202
       -
               This requires using <literal>pkgs.nginxQuic</literal> package

     

       203
       203
       -
               which can be achieved by setting <literal>services.nginx.package = pkgs.nginxQuic;</literal>.

     

       202
       202
       +
               This requires using `pkgs.nginxQuic` package

     

       203
       203
       +
               which can be achieved by setting `services.nginx.package = pkgs.nginxQuic;`.

     

       204
       204
        
               Note that HTTP 3 support is experimental and

     

       205
       205
        
               *not* yet recommended for production.

     

       206
       206
        
               Read more at https://quic.nginx.org/

+4 -4

nixos/modules/services/web-servers/tomcat.nix

···

       34
       34
        
             purifyOnStart = mkOption {

     

       35
       35
        
               type = types.bool;

     

       36
       36
        
               default = false;

     

       37
       37
       -
               description = ''

     

       37
       37
       +
               description = lib.mdDoc ''

     

       38
       38
        
                 On startup, the `baseDir` directory is populated with various files,

     

       39
       39
        
                 subdirectories and symlinks. If this option is enabled, these items

     

       40
       40
        
                 (except for the `logs` and `work` subdirectories) are first removed.

     
···

       46
       46
        
             baseDir = mkOption {

     

       47
       47
        
               type = lib.types.path;

     

       48
       48
        
               default = "/var/tomcat";

     

       49
       49
       -
               description = ''

     

       49
       49
       +
               description = lib.mdDoc ''

     

       50
       50
        
                 Location where Tomcat stores configuration files, web applications

     

       51
       51
        
                 and logfiles. Note that it is partially cleared on each service startup

     

       52
       52
        
                 if `purifyOnStart` is enabled.

     
···

       112
       112
        
             serverXml = mkOption {

     

       113
       113
        
               type = types.lines;

     

       114
       114
        
               default = "";

     

       115
       115
       -
               description = "

     

       115
       115
       +
               description = lib.mdDoc ''

     

       116
       116
        
                 Verbatim server.xml configuration.

     

       117
       117
        
                 This is mutually exclusive with the virtualHosts options.

     

       118
       118
       -
               ";

     

       118
       118
       +
               '';

     

       119
       119
        
             };

     

       120
       120
        
       

     

       121
       121
        
             commonLibs = mkOption {

+10 -10

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

···

       27
       27
        
             http_address = mkOption {

     

       28
       28
        
               type = types.str;

     

       29
       29
        
               default = "*:6081";

     

       30
       30
       -
               description = "

     

       30
       30
       +
               description = lib.mdDoc ''

     

       31
       31
        
                 HTTP listen address and port.

     

       32
       32
       -
               ";

     

       32
       32
       +
               '';

     

       33
       33
        
             };

     

       34
       34
        
       

     

       35
       35
        
             config = mkOption {

     

       36
       36
        
               type = types.lines;

     

       37
       37
       -
               description = "

     

       37
       37
       +
               description = lib.mdDoc ''

     

       38
       38
        
                 Verbatim default.vcl configuration.

     

       39
       39
       -
               ";

     

       39
       39
       +
               '';

     

       40
       40
        
             };

     

       41
       41
        
       

     

       42
       42
        
             stateDir = mkOption {

     

       43
       43
        
               type = types.path;

     

       44
       44
        
               default = "/var/spool/varnish/${config.networking.hostName}";

     

       45
       45
        
               defaultText = literalExpression ''"/var/spool/varnish/''${config.networking.hostName}"'';

     

       46
       46
       -
               description = "

     

       46
       46
       +
               description = lib.mdDoc ''

     

       47
       47
        
                 Directory holding all state for Varnish to run.

     

       48
       48
       -
               ";

     

       48
       48
       +
               '';

     

       49
       49
        
             };

     

       50
       50
        
       

     

       51
       51
        
             extraModules = mkOption {

     

       52
       52
        
               type = types.listOf types.package;

     

       53
       53
        
               default = [];

     

       54
       54
        
               example = literalExpression "[ pkgs.varnishPackages.geoip ]";

     

       55
       55
       -
               description = "

     

       55
       55
       +
               description = lib.mdDoc ''

     

       56
       56
        
                 Varnish modules (except 'std').

     

       57
       57
       -
               ";

     

       57
       57
       +
               '';

     

       58
       58
        
             };

     

       59
       59
        
       

     

       60
       60
        
             extraCommandLine = mkOption {

     

       61
       61
        
               type = types.str;

     

       62
       62
        
               default = "";

     

       63
       63
        
               example = "-s malloc,256M";

     

       64
       64
       -
               description = "

     

       64
       64
       +
               description = lib.mdDoc ''

     

       65
       65
        
                 Command line switches for varnishd (run 'varnishd -?' to get list of options)

     

       66
       66
       -
               ";

     

       66
       66
       +
               '';

     

       67
       67
        
             };

     

       68
       68
        
           };

     

       69
       69

+5 -5

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

···

       8
       8
        
           services.xserver.desktopManager.runXdgAutostartIfNone = mkOption {

     

       9
       9
        
             type = types.bool;

     

       10
       10
        
             default = false;

     

       11
       11
       -
             description = ''

     

       11
       11
       +
             description = lib.mdDoc ''

     

       12
       12
        
               Whether to run XDG autostart files for sessions without a desktop manager

     

       13
       13
        
               (with only a window manager), these sessions usually don't handle XDG

     

       14
       14
        
               autostart files by default.

     

       15
       15
        
       

     

       16
       16
       -
               Some services like <option>i18n.inputMethod</option> and

     

       17
       17
       -
               <option>service.earlyoom</option> use XDG autostart files to start.

     

       18
       18
       -
               If this option is not set to <literal>true</literal> and you are using

     

       16
       16
       +
               Some services like {option}`i18n.inputMethod` and

     

       17
       17
       +
               {option}`service.earlyoom` use XDG autostart files to start.

     

       18
       18
       +
               If this option is not set to `true` and you are using

     

       19
       19
        
               a window manager without a desktop manager, you need to manually start

     

       20
       20
       -
               them or running <package>dex</package> somewhere.

     

       20
       20
       +
               them or running `dex` somewhere.

     

       21
       21
        
             '';

     

       22
       22
        
           };

     

       23
       23
        
         };

+1 -1

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

···

       24
       24
        
         phocConfigType = types.submodule {

     

       25
       25
        
           options = {

     

       26
       26
        
             xwayland = mkOption {

     

       27
       27
       -
               description = ''

     

       27
       27
       +
               description = lib.mdDoc ''

     

       28
       28
        
                 Whether to enable XWayland support.

     

       29
       29
        
       

     

       30
       30
        
                 To start XWayland immediately, use `immediate`.

+2 -2

nixos/modules/system/activation/activation-script.nix

···

       92
       92
        
                     Whether this activation script supports being dry-activated.

     

       93
       93
        
                     These activation scripts will also be executed on dry-activate

     

       94
       94
        
                     activations with the environment variable

     

       95
       95
       -
                     <literal>NIXOS_ACTION</literal> being set to <literal>dry-activate

     

       96
       96
       -
                     </literal>.  it's important that these activation scripts  don't

     

       95
       95
       +
                     <literal>NIXOS_ACTION</literal> being set to <literal>dry-activate</literal>.

     

       96
       96
       +
                     it's important that these activation scripts  don't

     

       97
       97
        
                     modify anything about the system when the variable is set.

     

       98
       98
        
                   '';

     

       99
       99
        
                 };

+1 -1

nixos/modules/system/boot/kernel_config.nix

···

       91
       91
        
               USB? y

     

       92
       92
        
               DEBUG n

     

       93
       93
        
             '';

     

       94
       94
       -
             description = ''

     

       94
       94
       +
             description = lib.mdDoc ''

     

       95
       95
        
               The result of converting the structured kernel configuration in settings

     

       96
       96
        
               to an intermediate string that can be parsed by generate-config.pl to

     

       97
       97
        
               answer the kernel `make defconfig`.

+3 -3

nixos/modules/system/boot/luksroot.nix

···

       532
       532
        
           boot.initrd.luks.reusePassphrases = mkOption {

     

       533
       533
        
             type = types.bool;

     

       534
       534
        
             default = true;

     

       535
       535
       -
             description = ''

     

       535
       535
       +
             description = lib.mdDoc ''

     

       536
       536
        
               When opening a new LUKS device try reusing last successful

     

       537
       537
        
               passphrase.

     

       538
       538
        
       

     

       539
       539
        
               Useful for mounting a number of devices that use the same

     

       540
       540
        
               passphrase without retyping it several times.

     

       541
       541
        
       

     

       542
       542
       -
               Such setup can be useful if you use <command>cryptsetup

     

       543
       543
       -
               luksSuspend</command>. Different LUKS devices will still have

     

       542
       542
       +
               Such setup can be useful if you use {command}`cryptsetup luksSuspend`.

     

       543
       543
       +
               Different LUKS devices will still have

     

       544
       544
        
               different master keys even when using the same passphrase.

     

       545
       545
        
             '';

     

       546
       546
        
           };

+3 -3

nixos/modules/tasks/auto-upgrade.nix

···

       46
       46
        
               type = types.nullOr types.str;

     

       47
       47
        
               default = null;

     

       48
       48
        
               example = "https://nixos.org/channels/nixos-14.12-small";

     

       49
       49
       -
               description = ''

     

       49
       49
       +
               description = lib.mdDoc ''

     

       50
       50
        
                 The URI of the NixOS channel to use for automatic

     

       51
       51
        
                 upgrades. By default, this is the channel set using

     

       52
       52
       -
                 <command>nix-channel</command> (run <literal>nix-channel

     

       53
       53
       -
                 --list</literal> to see the current value).

     

       52
       52
       +
                 {command}`nix-channel` (run `nix-channel --list`

     

       53
       53
       +
                 to see the current value).

     

       54
       54
        
               '';

     

       55
       55
        
             };

     

       56
       56

+11 -12

nixos/modules/tasks/filesystems.nix

···

       175
       175
        
               }

     

       176
       176
        
             '';

     

       177
       177
        
             type = types.attrsOf (types.submodule [coreFileSystemOpts fileSystemOpts]);

     

       178
       178
       -
             description = ''

     

       178
       178
       +
             description = lib.mdDoc ''

     

       179
       179
        
               The file systems to be mounted.  It must include an entry for

     

       180
       180
       -
               the root directory (<literal>mountPoint = "/"</literal>).  Each

     

       180
       180
       +
               the root directory (`mountPoint = "/"`).  Each

     

       181
       181
        
               entry in the list is an attribute set with the following fields:

     

       182
       182
       -
               <literal>mountPoint</literal>, <literal>device</literal>,

     

       183
       183
       -
               <literal>fsType</literal> (a file system type recognised by

     

       184
       184
       -
               <command>mount</command>; defaults to

     

       185
       185
       -
               <literal>"auto"</literal>), and <literal>options</literal>

     

       186
       186
       -
               (the mount options passed to <command>mount</command> using the

     

       187
       187
       -
               <option>-o</option> flag; defaults to <literal>[ "defaults" ]</literal>).

     

       182
       182
       +
               `mountPoint`, `device`,

     

       183
       183
       +
               `fsType` (a file system type recognised by

     

       184
       184
       +
               {command}`mount`; defaults to

     

       185
       185
       +
               `"auto"`), and `options`

     

       186
       186
       +
               (the mount options passed to {command}`mount` using the

     

       187
       187
       +
               {option}`-o` flag; defaults to `[ "defaults" ]`).

     

       188
       188
        
       

     

       189
       189
       -
               Instead of specifying <literal>device</literal>, you can also

     

       190
       190
       -
               specify a volume label (<literal>label</literal>) for file

     

       191
       191
       -
               systems that support it, such as ext2/ext3 (see <command>mke2fs

     

       192
       192
       -
               -L</command>).

     

       189
       189
       +
               Instead of specifying `device`, you can also

     

       190
       190
       +
               specify a volume label (`label`) for file

     

       191
       191
       +
               systems that support it, such as ext2/ext3 (see {command}`mke2fs -L`).

     

       193
       192
        
             '';

     

       194
       193
        
           };

     

       195
       194

+1 -1

nixos/modules/tasks/filesystems/zfs.nix

···

       426
       426
        
             type = types.either (types.enum [ "disabled" "all" ]) (types.listOf types.str);

     

       427
       427
        
             default = "disabled";

     

       428
       428
        
             example = [ "tank" "dozer" ];

     

       429
       429
       -
             description = ''

     

       429
       429
       +
             description = lib.mdDoc ''

     

       430
       430
        
               After importing, expand each device in the specified pools.

     

       431
       431
        
       

     

       432
       432
        
               Set the value to the plain string "all" to expand all pools on boot:

+4 -4

nixos/modules/tasks/network-interfaces.nix

···

       785
       785
        
                     default = null;

     

       786
       786
        
                     example = "fast";

     

       787
       787
        
                     type = types.nullOr types.str;

     

       788
       788
       -
                     description = ''

     

       788
       788
       +
                     description = lib.mdDoc ''

     

       789
       789
        
                       DEPRECATED, use `driverOptions`.

     

       790
       790
        
                       Option specifying the rate in which we'll ask our link partner

     

       791
       791
        
                       to transmit LACPDU packets in 802.3ad mode.

     
···

       796
       796
        
                     default = null;

     

       797
       797
        
                     example = 100;

     

       798
       798
        
                     type = types.nullOr types.int;

     

       799
       799
       -
                     description = ''

     

       799
       799
       +
                     description = lib.mdDoc ''

     

       800
       800
        
                       DEPRECATED, use `driverOptions`.

     

       801
       801
        
                       Miimon is the number of millisecond in between each round of polling

     

       802
       802
        
                       by the device driver for failed links. By default polling is not

     
···

       809
       809
        
                     default = null;

     

       810
       810
        
                     example = "active-backup";

     

       811
       811
        
                     type = types.nullOr types.str;

     

       812
       812
       -
                     description = ''

     

       812
       812
       +
                     description = lib.mdDoc ''

     

       813
       813
        
                       DEPRECATED, use `driverOptions`.

     

       814
       814
        
                       The mode which the bond will be running. The default mode for

     

       815
       815
        
                       the bonding driver is balance-rr, optimizing for throughput.

     
···

       822
       822
        
                     default = null;

     

       823
       823
        
                     example = "layer2+3";

     

       824
       824
        
                     type = types.nullOr types.str;

     

       825
       825
       -
                     description = ''

     

       825
       825
       +
                     description = lib.mdDoc ''

     

       826
       826
        
                       DEPRECATED, use `driverOptions`.

     

       827
       827
        
                       Selects the transmit hash policy to use for slave selection in

     

       828
       828
        
                       balance-xor, 802.3ad, and tlb modes.

+1 -1

nixos/modules/virtualisation/amazon-options.nix

···

       14
       14
        
               };

     

       15
       15
        
       

     

       16
       16
        
               datasets = lib.mkOption {

     

       17
       17
       -
                 description = ''

     

       17
       17
       +
                 description = lib.mdDoc ''

     

       18
       18
        
                   Datasets to create under the `tank` and `boot` zpools.

     

       19
       19
        
       

     

       20
       20
        
                   **NOTE:** This option is used only at image creation time, and

+1 -1

nixos/modules/virtualisation/azure-image.nix

···

       12
       12
        
             type = with types; either (enum [ "auto" ]) int;

     

       13
       13
        
             default = "auto";

     

       14
       14
        
             example = 2048;

     

       15
       15
       -
             description = ''

     

       15
       15
       +
             description = lib.mdDoc ''

     

       16
       16
        
               Size of disk image. Unit is MB.

     

       17
       17
        
             '';

     

       18
       18
        
           };

+3 -3

nixos/modules/virtualisation/google-compute-image.nix

···

       21
       21
        
             type = with types; either (enum [ "auto" ]) int;

     

       22
       22
        
             default = "auto";

     

       23
       23
        
             example = 1536;

     

       24
       24
       -
             description = ''

     

       24
       24
       +
             description = lib.mdDoc ''

     

       25
       25
        
               Size of disk image. Unit is MB.

     

       26
       26
        
             '';

     

       27
       27
        
           };

     
···

       29
       29
        
           virtualisation.googleComputeImage.configFile = mkOption {

     

       30
       30
        
             type = with types; nullOr str;

     

       31
       31
        
             default = null;

     

       32
       32
       -
             description = ''

     

       32
       32
       +
             description = lib.mdDoc ''

     

       33
       33
        
               A path to a configuration file which will be placed at `/etc/nixos/configuration.nix`

     

       34
       34
        
               and be used when switching to a new configuration.

     

       35
       35
        
               If set to `null`, a default configuration is used, where the only import is

     
···

       40
       40
        
           virtualisation.googleComputeImage.compressionLevel = mkOption {

     

       41
       41
        
             type = types.int;

     

       42
       42
        
             default = 6;

     

       43
       43
       -
             description = ''

     

       43
       43
       +
             description = lib.mdDoc ''

     

       44
       44
        
               GZIP compression level of the resulting disk image (1-9).

     

       45
       45
        
             '';

     

       46
       46
        
           };

+3 -3

nixos/modules/virtualisation/hyperv-image.nix

···

       12
       12
        
               type = with types; either (enum [ "auto" ]) int;

     

       13
       13
        
               default = "auto";

     

       14
       14
        
               example = 2048;

     

       15
       15
       -
               description = ''

     

       15
       15
       +
               description = lib.mdDoc ''

     

       16
       16
        
                 The size of the hyper-v base image in MiB.

     

       17
       17
        
               '';

     

       18
       18
        
             };

     

       19
       19
        
             vmDerivationName = mkOption {

     

       20
       20
        
               type = types.str;

     

       21
       21
        
               default = "nixos-hyperv-${config.system.nixos.label}-${pkgs.stdenv.hostPlatform.system}";

     

       22
       22
       -
               description = ''

     

       22
       22
       +
               description = lib.mdDoc ''

     

       23
       23
        
                 The name of the derivation for the hyper-v appliance.

     

       24
       24
        
               '';

     

       25
       25
        
             };

     

       26
       26
        
             vmFileName = mkOption {

     

       27
       27
        
               type = types.str;

     

       28
       28
        
               default = "nixos-${config.system.nixos.label}-${pkgs.stdenv.hostPlatform.system}.vhdx";

     

       29
       29
       -
               description = ''

     

       29
       29
       +
               description = lib.mdDoc ''

     

       30
       30
        
                 The file name of the hyper-v appliance.

     

       31
       31
        
               '';

     

       32
       32
        
             };

+4 -4

nixos/modules/virtualisation/kvmgt.nix

···

       10
       10
        
         vgpuOptions = {

     

       11
       11
        
           uuid = mkOption {

     

       12
       12
        
             type = with types; listOf str;

     

       13
       13
       -
             description = "UUID(s) of VGPU device. You can generate one with <package>libossp_uuid</package>.";

     

       13
       13
       +
             description = lib.mdDoc "UUID(s) of VGPU device. You can generate one with `libossp_uuid`.";

     

       14
       14
        
           };

     

       15
       15
        
         };

     

       16
       16
        
       

     
···

       31
       31
        
             vgpus = mkOption {

     

       32
       32
        
               default = {};

     

       33
       33
        
               type = with types; attrsOf (submodule [ { options = vgpuOptions; } ]);

     

       34
       34
       -
               description = ''

     

       35
       35
       -
                 Virtual GPUs to be used in Qemu. You can find devices via <command>ls /sys/bus/pci/devices/*/mdev_supported_types</command>

     

       36
       36
       -
                 and find info about device via <command>cat /sys/bus/pci/devices/*/mdev_supported_types/i915-GVTg_V5_4/description</command>

     

       34
       34
       +
               description = lib.mdDoc ''

     

       35
       35
       +
                 Virtual GPUs to be used in Qemu. You can find devices via {command}`ls /sys/bus/pci/devices/*/mdev_supported_types`

     

       36
       36
       +
                 and find info about device via {command}`cat /sys/bus/pci/devices/*/mdev_supported_types/i915-GVTg_V5_4/description`

     

       37
       37
        
               '';

     

       38
       38
        
               example = {

     

       39
       39
        
                 i915-GVTg_V5_8.uuid = [ "a297db4a-f4c2-11e6-90f6-d3b88d6c9525" ];

+1 -1

nixos/modules/virtualisation/libvirtd.nix

···

       81
       81
        
               type = types.package;

     

       82
       82
        
               default = pkgs.qemu;

     

       83
       83
        
               defaultText = literalExpression "pkgs.qemu";

     

       84
       84
       -
               description = ''

     

       84
       84
       +
               description = lib.mdDoc ''

     

       85
       85
        
                 Qemu package to use with libvirt.

     

       86
       86
        
                 `pkgs.qemu` can emulate alien architectures (e.g. aarch64 on x86)

     

       87
       87
        
                 `pkgs.qemu_kvm` saves disk space allowing to emulate only host architectures.

+2 -3

nixos/modules/virtualisation/lxc.nix

···

       53
       53
        
               type = types.lines;

     

       54
       54
        
               default = "";

     

       55
       55
        
               description =

     

       56
       56
       -
                 ''

     

       56
       56
       +
                 lib.mdDoc ''

     

       57
       57
        
                   This is the config file for managing unprivileged user network

     

       58
       58
       -
                   administration access in LXC. See <citerefentry><refentrytitle>lxc-usernet</refentrytitle><manvolnum>5</manvolnum>

     

       59
       59
       -
                   </citerefentry>.

     

       58
       58
       +
                   administration access in LXC. See {manpage}`lxc-usernet(5)`.

     

       60
       59
        
                 '';

     

       61
       60
        
             };

     

       62
       61
        
         };

+5 -5

nixos/modules/virtualisation/nixos-containers.nix

···

       536
       536
        
                     type = types.path;

     

       537
       537
        
                     default = pkgs.path;

     

       538
       538
        
                     defaultText = literalExpression "pkgs.path";

     

       539
       539
       -
                     description = ''

     

       539
       539
       +
                     description = lib.mdDoc ''

     

       540
       540
        
                       A path to the nixpkgs that provide the modules, pkgs and lib for evaluating the container.

     

       541
       541
        
       

     

       542
       542
       -
                       To only change the <literal>pkgs</literal> argument used inside the container modules,

     

       543
       543
       -
                       set the <literal>nixpkgs.*</literal> options in the container <option>config</option>.

     

       544
       544
       -
                       Setting <literal>config.nixpkgs.pkgs = pkgs</literal> speeds up the container evaluation

     

       545
       545
       -
                       by reusing the system pkgs, but the <literal>nixpkgs.config</literal> option in the

     

       542
       542
       +
                       To only change the `pkgs` argument used inside the container modules,

     

       543
       543
       +
                       set the `nixpkgs.*` options in the container {option}`config`.

     

       544
       544
       +
                       Setting `config.nixpkgs.pkgs = pkgs` speeds up the container evaluation

     

       545
       545
       +
                       by reusing the system pkgs, but the `nixpkgs.config` option in the

     

       546
       546
        
                       container config is ignored in this case.

     

       547
       547
        
                     '';

     

       548
       548
        
                   };

+1 -1

nixos/modules/virtualisation/openstack-options.nix

···

       15
       15
        
               };

     

       16
       16
        
       

     

       17
       17
        
               datasets = lib.mkOption {

     

       18
       18
       -
                 description = ''

     

       18
       18
       +
                 description = lib.mdDoc ''

     

       19
       19
        
                   Datasets to create under the `tank` and `boot` zpools.

     

       20
       20
        
       

     

       21
       21
        
                   **NOTE:** This option is used only at image creation time, and

+1 -1

nixos/modules/virtualisation/parallels-guest.nix

···

       23
       23
        
             autoMountShares = mkOption {

     

       24
       24
        
               type = types.bool;

     

       25
       25
        
               default = true;

     

       26
       26
       -
               description = ''

     

       26
       26
       +
               description = lib.mdDoc ''

     

       27
       27
        
                 Control prlfsmountd service. When this service is running, shares can not be manually

     

       28
       28
        
                 mounted through `mount -t prl_fs ...` as this service will remount and trample any set options.

     

       29
       29
        
                 Recommended to enable for simple file sharing, but extended share use such as for code should

+3 -3

nixos/modules/virtualisation/podman/network-socket.nix

···

       17
       17
        
           enable = mkOption {

     

       18
       18
        
             type = types.bool;

     

       19
       19
        
             default = false;

     

       20
       20
       -
             description = ''

     

       20
       20
       +
             description = lib.mdDoc ''

     

       21
       21
        
               Make the Podman and Docker compatibility API available over the network

     

       22
       22
        
               with TLS client certificate authentication.

     

       23
       23
        
       

     

       24
       24
        
               This allows Docker clients to connect with the equivalents of the Docker

     

       25
       25
       -
               CLI <literal>-H</literal> and <literal>--tls*</literal> family of options.

     

       25
       25
       +
               CLI `-H` and `--tls*` family of options.

     

       26
       26
        
       

     

       27
       27
        
               For certificate setup, see https://docs.docker.com/engine/security/protect-access/

     

       28
       28
        
       

     

       29
       29
       -
               This option is independent of <xref linkend="opt-virtualisation.podman.dockerSocket.enable"/>.

     

       29
       29
       +
               This option is independent of [](#opt-virtualisation.podman.dockerSocket.enable).

     

       30
       30
        
             '';

     

       31
       31
        
           };

     

       32
       32

+13 -13

nixos/modules/virtualisation/proxmox-image.nix

···

       10
       10
        
               type = types.str;

     

       11
       11
        
               default = "";

     

       12
       12
        
               example = "order=scsi0;net0";

     

       13
       13
       -
               description = ''

     

       13
       13
       +
               description = lib.mdDoc ''

     

       14
       14
        
                 Default boot device. PVE will try all devices in its default order if this value is empty.

     

       15
       15
        
               '';

     

       16
       16
        
             };

     
···

       18
       18
        
               type = types.str;

     

       19
       19
        
               default = "virtio-scsi-pci";

     

       20
       20
        
               example = "lsi";

     

       21
       21
       -
               description = ''

     

       21
       21
       +
               description = lib.mdDoc ''

     

       22
       22
        
                 SCSI controller type. Must be one of the supported values given in

     

       23
       23
       -
                 <link xlink:href="https://pve.proxmox.com/wiki/Qemu/KVM_Virtual_Machines"/>

     

       23
       23
       +
                 <https://pve.proxmox.com/wiki/Qemu/KVM_Virtual_Machines>

     

       24
       24
        
               '';

     

       25
       25
        
             };

     

       26
       26
        
             virtio0 = mkOption {

     

       27
       27
        
               type = types.str;

     

       28
       28
        
               default = "local-lvm:vm-9999-disk-0";

     

       29
       29
        
               example = "ceph:vm-123-disk-0";

     

       30
       30
       -
               description = ''

     

       30
       30
       +
               description = lib.mdDoc ''

     

       31
       31
        
                 Configuration for the default virtio disk. It can be used as a cue for PVE to autodetect the target sotrage.

     

       32
       32
        
                 This parameter is required by PVE even if it isn't used.

     

       33
       33
        
               '';

     
···

       35
       35
        
             ostype = mkOption {

     

       36
       36
        
               type = types.str;

     

       37
       37
        
               default = "l26";

     

       38
       38
       -
               description = ''

     

       38
       38
       +
               description = lib.mdDoc ''

     

       39
       39
        
                 Guest OS type

     

       40
       40
        
               '';

     

       41
       41
        
             };

     

       42
       42
        
             cores = mkOption {

     

       43
       43
        
               type = types.ints.positive;

     

       44
       44
        
               default = 1;

     

       45
       45
       -
               description = ''

     

       45
       45
       +
               description = lib.mdDoc ''

     

       46
       46
        
                 Guest core count

     

       47
       47
        
               '';

     

       48
       48
        
             };

     

       49
       49
        
             memory = mkOption {

     

       50
       50
        
               type = types.ints.positive;

     

       51
       51
        
               default = 1024;

     

       52
       52
       -
               description = ''

     

       52
       52
       +
               description = lib.mdDoc ''

     

       53
       53
        
                 Guest memory in MB

     

       54
       54
        
               '';

     

       55
       55
        
             };

     
···

       58
       58
        
             name = mkOption {

     

       59
       59
        
               type = types.str;

     

       60
       60
        
               default = "nixos-${config.system.nixos.label}";

     

       61
       61
       -
               description = ''

     

       61
       61
       +
               description = lib.mdDoc ''

     

       62
       62
        
                 VM name

     

       63
       63
        
               '';

     

       64
       64
        
             };

     

       65
       65
        
             net0 = mkOption {

     

       66
       66
        
               type = types.commas;

     

       67
       67
        
               default = "virtio=00:00:00:00:00:00,bridge=vmbr0,firewall=1";

     

       68
       68
       -
               description = ''

     

       68
       68
       +
               description = lib.mdDoc ''

     

       69
       69
        
                 Configuration for the default interface. When restoring from VMA, check the

     

       70
       70
        
                 "unique" box to ensure device mac is randomized.

     

       71
       71
        
               '';

     
···

       74
       74
        
               type = types.str;

     

       75
       75
        
               default = "socket";

     

       76
       76
        
               example = "/dev/ttyS0";

     

       77
       77
       -
               description = ''

     

       77
       77
       +
               description = lib.mdDoc ''

     

       78
       78
        
                 Create a serial device inside the VM (n is 0 to 3), and pass through a host serial device (i.e. /dev/ttyS0),

     

       79
       79
        
                 or create a unix socket on the host side (use qm terminal to open a terminal connection).

     

       80
       80
        
               '';

     
···

       83
       83
        
               type = types.bool;

     

       84
       84
        
               apply = x: if x then "1" else "0";

     

       85
       85
        
               default = true;

     

       86
       86
       -
               description = ''

     

       86
       86
       +
               description = lib.mdDoc ''

     

       87
       87
        
                 Expect guest to have qemu agent running

     

       88
       88
        
               '';

     

       89
       89
        
             };

     
···

       95
       95
        
               cpu = "host";

     

       96
       96
        
               onboot = 1;

     

       97
       97
        
             }'';

     

       98
       98
       -
             description = ''

     

       98
       98
       +
             description = lib.mdDoc ''

     

       99
       99
        
               Additional options appended to qemu-server.conf

     

       100
       100
        
             '';

     

       101
       101
        
           };

     
···

       103
       103
        
             type = types.str;

     

       104
       104
        
             default = config.proxmox.qemuConf.name;

     

       105
       105
        
             example = "999-nixos_template";

     

       106
       106
       -
             description = ''

     

       106
       106
       +
             description = lib.mdDoc ''

     

       107
       107
        
               Filename of the image will be vzdump-qemu-''${filenameSuffix}.vma.zstd.

     

       108
       108
        
               This will also determine the default name of the VM on restoring the VMA.

     

       109
       109
        
               Start this value with a number if you want the VMA to be detected as a backup of

+4 -4

nixos/modules/virtualisation/qemu-vm.nix

···

       739
       739
        
               type = types.nullOr types.package;

     

       740
       740
        
               default = null;

     

       741
       741
        
               description =

     

       742
       742
       -
                 ''

     

       743
       743
       -
                   An alternate BIOS (such as <package>qboot</package>) with which to start the VM.

     

       744
       744
       -
                   Should contain a file named <literal>bios.bin</literal>.

     

       745
       745
       -
                   If <literal>null</literal>, QEMU's builtin SeaBIOS will be used.

     

       742
       742
       +
                 lib.mdDoc ''

     

       743
       743
       +
                   An alternate BIOS (such as `qboot`) with which to start the VM.

     

       744
       744
       +
                   Should contain a file named `bios.bin`.

     

       745
       745
       +
                   If `null`, QEMU's builtin SeaBIOS will be used.

     

       746
       746
        
                 '';

     

       747
       747
        
             };

     

       748
       748

+5 -5

nixos/modules/virtualisation/vmware-image.nix

···

       21
       21
        
               type = with types; either (enum [ "auto" ]) int;

     

       22
       22
        
               default = "auto";

     

       23
       23
        
               example = 2048;

     

       24
       24
       -
               description = ''

     

       24
       24
       +
               description = lib.mdDoc ''

     

       25
       25
        
                 The size of the VMWare base image in MiB.

     

       26
       26
        
               '';

     

       27
       27
        
             };

     

       28
       28
        
             vmDerivationName = mkOption {

     

       29
       29
        
               type = types.str;

     

       30
       30
        
               default = "nixos-vmware-${config.system.nixos.label}-${pkgs.stdenv.hostPlatform.system}";

     

       31
       31
       -
               description = ''

     

       31
       31
       +
               description = lib.mdDoc ''

     

       32
       32
        
                 The name of the derivation for the VMWare appliance.

     

       33
       33
        
               '';

     

       34
       34
        
             };

     

       35
       35
        
             vmFileName = mkOption {

     

       36
       36
        
               type = types.str;

     

       37
       37
        
               default = "nixos-${config.system.nixos.label}-${pkgs.stdenv.hostPlatform.system}.vmdk";

     

       38
       38
       -
               description = ''

     

       38
       38
       +
               description = lib.mdDoc ''

     

       39
       39
        
                 The file name of the VMWare appliance.

     

       40
       40
        
               '';

     

       41
       41
        
             };

     

       42
       42
        
             vmSubformat = mkOption {

     

       43
       43
        
               type = types.enum subformats;

     

       44
       44
        
               default = "monolithicSparse";

     

       45
       45
       -
               description = "Specifies which VMDK subformat to use.";

     

       45
       45
       +
               description = lib.mdDoc "Specifies which VMDK subformat to use.";

     

       46
       46
        
             };

     

       47
       47
        
             vmCompat6 = mkOption {

     

       48
       48
        
               type = types.bool;

     

       49
       49
        
               default = false;

     

       50
       50
        
               example = true;

     

       51
       51
       -
               description = "Create a VMDK version 6 image (instead of version 4).";

     

       51
       51
       +
               description = lib.mdDoc "Create a VMDK version 6 image (instead of version 4).";

     

       52
       52
        
             };

     

       53
       53
        
           };

     

       54
       54
        
         };

+1

nixos/tests/installed-tests/default.nix

···

       98
       98
        
         gnome-photos = callInstalledTest ./gnome-photos.nix {};

     

       99
       99
        
         graphene = callInstalledTest ./graphene.nix {};

     

       100
       100
        
         gsconnect = callInstalledTest ./gsconnect.nix {};

     

       101
       101
       +
         json-glib = callInstalledTest ./json-glib.nix {};

     

       101
       102
        
         ibus = callInstalledTest ./ibus.nix {};

     

       102
       103
        
         libgdata = callInstalledTest ./libgdata.nix {};

     

       103
       104
        
         librsvg = callInstalledTest ./librsvg.nix {};

+5

nixos/tests/installed-tests/json-glib.nix

···

       1
       1
       +
       { pkgs, makeInstalledTest, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       makeInstalledTest {

     

       4
       4
       +
         tested = pkgs.json-glib;

     

       5
       5
       +
       }

+2 -5

pkgs/applications/audio/bitwig-studio/bitwig-studio1.nix

···

       27
       27
        
           libxkbfile pixman xcbutil xcbutilwm zlib

     

       28
       28
        
         ];

     

       29
       29
        
       

     

       30
       30
       -
         binPath = lib.makeBinPath [

     

       31
       31
       -
           xdg-utils zenity ffmpeg

     

       32
       32
       -
         ];

     

       33
       33
       -
       

     

       34
       30
        
         installPhase = ''

     

       35
       31
        
           mkdir -p $out

     

       36
       32
        
           cp -r opt/bitwig-studio $out/libexec

     
···

       77
       73
        
             -not -path '*/resources/*' | \

     

       78
       74
        
           while IFS= read -r f ; do

     

       79
       75
        
             wrapProgram $f \

     

       80
       80
       -
               --prefix PATH : "${binPath}" \

     

       76
       76
       +
               --suffix PATH : "${lib.makeBinPath [ ffmpeg zenity ]}" \

     

       77
       77
       +
               --prefix PATH : "${lib.makeBinPath [ xdg-utils ]}" \

     

       81
       78
        
               "''${gappsWrapperArgs[@]}" \

     

       82
       79
        
               --set LD_PRELOAD "${libxkbcommon.out}/lib/libxkbcommon.so" || true

     

       83
       80
        
           done

+3 -6

pkgs/applications/audio/bitwig-studio/bitwig-studio3.nix

···

       27
       27
        
           alsa-lib cairo freetype gdk-pixbuf glib gtk3 libxcb xcbutil xcbutilwm zlib libXtst libxkbcommon pulseaudio libjack2 libX11 libglvnd libXcursor stdenv.cc.cc.lib

     

       28
       28
        
         ];

     

       29
       29
        
       

     

       30
       30
       -
         binPath = lib.makeBinPath [

     

       31
       31
       -
           xdg-utils ffmpeg

     

       32
       32
       -
         ];

     

       33
       33
       -
       

     

       34
       30
        
         ldLibraryPath = lib.strings.makeLibraryPath buildInputs;

     

       35
       31
        
       

     

       36
       32
        
         installPhase = ''

     
···

       60
       56
        
             patchelf --set-interpreter "${stdenv.cc.bintools.dynamicLinker}" $f

     

       61
       57
        
             wrapProgram $f \

     

       62
       58
        
               "''${gappsWrapperArgs[@]}" \

     

       63
       63
       -
               --prefix PATH : "${binPath}" \

     

       64
       64
       -
               --suffix LD_LIBRARY_PATH : "${ldLibraryPath}"

     

       59
       59
       +
               --prefix LD_LIBRARY_PATH : "${ldLibraryPath}" \

     

       60
       60
       +
               --prefix PATH : "${lib.makeBinPath [ ffmpeg ]}" \

     

       61
       61
       +
               --suffix PATH : "${lib.makeBinPath [ xdg-utils ]}"

     

       65
       62
        
           done

     

       66
       63
        
       

     

       67
       64
        
         '';

+3 -1

pkgs/applications/audio/bitwig-studio/bitwig-studio4.nix

···

       53
       53
        
             -not -path '*/resources/*' | \

     

       54
       54
        
           while IFS= read -r f ; do

     

       55
       55
        
             patchelf --set-interpreter "${stdenv.cc.bintools.dynamicLinker}" $f

     

       56
       56
       +
             # make xdg-open overrideable at runtime

     

       56
       57
        
             wrapProgram $f \

     

       57
       58
        
               "''${gappsWrapperArgs[@]}" \

     

       58
       58
       -
               --prefix PATH : "${lib.makeBinPath [ xdg-utils ffmpeg ]}" \

     

       59
       59
       +
               --prefix PATH : "${lib.makeBinPath [ ffmpeg ]}" \

     

       60
       60
       +
               --suffix PATH : "${lib.makeBinPath [ xdg-utils ]}" \

     

       59
       61
        
               --suffix LD_LIBRARY_PATH : "${lib.strings.makeLibraryPath buildInputs}"

     

       60
       62
        
           done

     

       61
       63

+2 -4

pkgs/applications/audio/mid2key/default.nix

···

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "dnschneid";

     

       9
       9
        
           repo = "mid2key";

     

       10
       10
       -
           rev = "v${version}";

     

       11
       11
       -
           sha256 = "0j2vsjvdgx51nd1qmaa18mcy0yw9pwrhbv2mdwnf913bwsk4y904";

     

       10
       10
       +
           rev = "r${version}";

     

       11
       11
       +
           sha256 = "Zo0mqdBJ1JKD9ZCA8te3f5opyYslFncYcx9iuXq2B9g=";

     

       12
       12
        
         };

     

       13
       13
       -
       

     

       14
       14
       -
         unpackPhase = "tar xvzf $src";

     

       15
       13
        
       

     

       16
       14
        
         buildInputs = [ alsa-lib libX11 libXi libXtst xorgproto ];

     

       17
       15

+2 -1

pkgs/applications/finance/irpf/default.nix

···

       44
       44
        
           install -Dm755 irpf.jar "$BASEDIR/${pname}.jar"

     

       45
       45
        
           install -Dm644 Leia-me.htm offline.png online.png pgd-updater.jar "$BASEDIR"

     

       46
       46
        
       

     

       47
       47
       +
           # make xdg-open overrideable at runtime

     

       47
       48
        
           makeWrapper ${jdk11}/bin/java $out/bin/${pname} \

     

       48
       49
        
             --add-flags "-Dawt.useSystemAAFontSettings=on" \

     

       49
       50
        
             --add-flags "-Dswing.aatext=true" \

     

       50
       51
        
             --add-flags "-jar $BASEDIR/${pname}.jar" \

     

       51
       51
       -
             --prefix PATH : ${lib.makeBinPath [ xdg-utils ]} \

     

       52
       52
       +
             --suffix PATH : ${lib.makeBinPath [ xdg-utils ]} \

     

       52
       53
        
             --set _JAVA_AWT_WM_NONREPARENTING 1 \

     

       53
       54
        
             --set AWT_TOOLKIT MToolkit

     

       54
       55

+3 -1

pkgs/applications/graphics/shutter/default.nix

···

       94
       94
        
         '';

     

       95
       95
        
       

     

       96
       96
        
         preFixup = ''

     

       97
       97
       +
           # make xdg-open overrideable at runtime

     

       97
       98
        
           gappsWrapperArgs+=(

     

       98
       99
        
             --set PERL5LIB ${perlPackages.makePerlPath perlModules} \

     

       99
       99
       -
             --prefix PATH : ${lib.makeBinPath [ imagemagick xdg-utils ] }

     

       100
       100
       +
             --prefix PATH : ${lib.makeBinPath [ imagemagick ] }

     

       101
       101
       +
             --suffix PATH : ${lib.makeBinPath [ xdg-utils ] }

     

       100
       102
        
           )

     

       101
       103
        
         '';

     

       102
       104

+2 -1

pkgs/applications/misc/1password-gui/beta.nix

···

       126
       126
        
             # Electron is trying to open udev via dlopen()

     

       127
       127
        
             # and for some reason that doesn't seem to be impacted from the rpath.

     

       128
       128
        
             # Adding udev to LD_LIBRARY_PATH fixes that.

     

       129
       129
       +
             # Make xdg-open overrideable at runtime.

     

       129
       130
        
             makeWrapper $out/share/1password/1password $out/bin/1password \

     

       130
       130
       -
               --prefix PATH : ${lib.makeBinPath [ xdg-utils ]} \

     

       131
       131
       +
               --suffix PATH : ${lib.makeBinPath [ xdg-utils ]} \

     

       131
       132
        
               --prefix LD_LIBRARY_PATH : ${lib.makeLibraryPath [ udev ]}

     

       132
       133
        
       

     

       133
       134
        
             runHook postInstall

+2 -1

pkgs/applications/misc/1password-gui/default.nix

···

       126
       126
        
             # Electron is trying to open udev via dlopen()

     

       127
       127
        
             # and for some reason that doesn't seem to be impacted from the rpath.

     

       128
       128
        
             # Adding udev to LD_LIBRARY_PATH fixes that.

     

       129
       129
       +
             # Make xdg-open overrideable at runtime.

     

       129
       130
        
             makeWrapper $out/share/1password/1password $out/bin/1password \

     

       130
       130
       -
               --prefix PATH : ${lib.makeBinPath [ xdg-utils ]} \

     

       131
       131
       +
               --suffix PATH : ${lib.makeBinPath [ xdg-utils ]} \

     

       131
       132
        
               --prefix LD_LIBRARY_PATH : ${lib.makeLibraryPath [ udev ]}

     

       132
       133
        
       

     

       133
       134
        
             runHook postInstall

+1 -1

pkgs/applications/misc/avrdudess/default.nix

···

       25
       25
        
           export LD_LIBRARY_PATH="${lib.makeLibraryPath [gtk2 mono]}"

     

       26
       26
        
           # We need PATH from user env for xdg-open to find its tools, which

     

       27
       27
        
           # typically depend on the currently running desktop environment.

     

       28
       28
       -
           export PATH="${lib.makeBinPath [ avrdude xdg-utils ]}:\$PATH"

     

       28
       28
       +
           export PATH="\$PATH:${lib.makeBinPath [ avrdude xdg-utils ]}"

     

       29
       29
        
       

     

       30
       30
        
           # avrdudess must have its resource files in its current working directory

     

       31
       31
        
           cd $out/avrdudess && exec ${mono}/bin/mono "$out/avrdudess/avrdudess.exe" "\$@"

+6 -1

pkgs/applications/misc/blender/default.nix

···

       6
       6
        
       , zlib, zstd, fftw, opensubdiv, freetype, jemalloc, ocl-icd, addOpenGLRunpath

     

       7
       7
        
       , jackaudioSupport ? false, libjack2

     

       8
       8
        
       , cudaSupport ? config.cudaSupport or false, cudaPackages ? {}

     

       9
       9
       +
       , hipSupport ? false, hip # comes with a significantly larger closure size

     

       9
       10
        
       , colladaSupport ? true, opencollada

     

       10
       11
        
       , spaceNavSupport ? stdenv.isLinux, libspnav

     

       11
       12
        
       , makeWrapper

     
···

       86
       87
        
                         '${python310Packages.numpy}/${python.sitePackages}/numpy'

     

       87
       88
        
           '' else ''

     

       88
       89
        
             substituteInPlace extern/clew/src/clew.c --replace '"libOpenCL.so"' '"${ocl-icd}/lib/libOpenCL.so"'

     

       89
       89
       -
           '');

     

       90
       90
       +
           '') +

     

       91
       91
       +
           (if hipSupport then ''

     

       92
       92
       +
             substituteInPlace extern/hipew/src/hipew.c --replace '"/opt/rocm/hip/lib/libamdhip64.so"' '"${hip}/lib/libamdhip64.so"'

     

       93
       93
       +
             substituteInPlace extern/hipew/src/hipew.c --replace '"opt/rocm/hip/bin"' '"${hip}/bin"'

     

       94
       94
       +
           '' else "");

     

       90
       95
        
       

     

       91
       96
        
         cmakeFlags =

     

       92
       97
        
           [

+3 -2

pkgs/applications/misc/far2l/default.nix

···

       61
       61
        
           PYTHON = withPython;

     

       62
       62
        
         };

     

       63
       63
        
       

     

       64
       64
       -
         runtimeDeps = [ unzip zip p7zip xz gzip bzip2 gnutar xdg-utils ];

     

       64
       64
       +
         runtimeDeps = [ unzip zip p7zip xz gzip bzip2 gnutar ];

     

       65
       65
        
       

     

       66
       66
        
         postInstall = ''

     

       67
       67
        
           wrapProgram $out/bin/far2l \

     

       68
       68
        
             --argv0 $out/bin/far2l \

     

       69
       69
       -
             --prefix PATH : ${lib.makeBinPath runtimeDeps}

     

       69
       69
       +
             --prefix PATH : ${lib.makeBinPath runtimeDeps} \

     

       70
       70
       +
             --suffix PATH : ${lib.makeBinPath [ xdg-utils ]}

     

       70
       71
        
         '';

     

       71
       72
        
       

     

       72
       73
        
         meta = with lib; {

+2 -1

pkgs/applications/misc/nwg-drawer/default.nix

···

       33
       33
        
         '';

     

       34
       34
        
       

     

       35
       35
        
         preFixup = ''

     

       36
       36
       +
           # make xdg-open overrideable at runtime

     

       36
       37
        
           gappsWrapperArgs+=(

     

       37
       37
       -
             --prefix PATH : ${xdg-utils}/bin

     

       38
       38
       +
             --suffix PATH : ${xdg-utils}/bin

     

       38
       39
        
             --prefix XDG_DATA_DIRS : $out/share

     

       39
       40
        
           )

     

       40
       41
        
         '';

+2 -1

pkgs/applications/networking/appgate-sdp/default.nix

···

       141
       141
        
               --prefix PATH : ${makeBinPath [ iproute2 networkmanager dnsmasq ]} \

     

       142
       142
        
               --set LD_LIBRARY_PATH $out/opt/appgate/service

     

       143
       143
        
       

     

       144
       144
       +
           # make xdg-open overrideable at runtime

     

       144
       145
        
           makeWrapper $out/opt/appgate/Appgate $out/bin/appgate \

     

       145
       145
       -
               --prefix PATH : ${makeBinPath [ xdg-utils ]} \

     

       146
       146
       +
               --suffix PATH : ${makeBinPath [ xdg-utils ]} \

     

       146
       147
        
               --set LD_LIBRARY_PATH $out/opt/appgate:${makeLibraryPath deps}

     

       147
       148
        
       

     

       148
       149
        
           wrapProgram $out/opt/appgate/linux/set_dns --set PYTHONPATH $PYTHONPATH

+2 -1

pkgs/applications/networking/browsers/brave/default.nix

···

       73
       73
        
           libxkbcommon libXScrnSaver libXcomposite libXcursor libXdamage

     

       74
       74
        
           libXext libXfixes libXi libXrandr libXrender libxshmfence

     

       75
       75
        
           libXtst libuuid mesa nspr nss pango pipewire udev wayland

     

       76
       76
       -
           xdg-utils xorg.libxcb zlib snappy

     

       76
       76
       +
           xorg.libxcb zlib snappy

     

       77
       77
        
         ]

     

       78
       78
        
           ++ optional pulseSupport libpulseaudio

     

       79
       79
        
           ++ optional libvaSupport libva;

     
···

       170
       170
        
           gappsWrapperArgs+=(

     

       171
       171
        
             --prefix LD_LIBRARY_PATH : ${rpath}

     

       172
       172
        
             --prefix PATH : ${binpath}

     

       173
       173
       +
             --suffix PATH : ${lib.makeBinPath [ xdg-utils ]}

     

       173
       174
        
             ${optionalString (enableFeatures != []) ''

     

       174
       175
        
             --add-flags "--enable-features=${strings.concatStringsSep "," enableFeatures}"

     

       175
       176
        
             ''}

+2 -1

pkgs/applications/networking/browsers/firefox/wrapper.nix

···

       271
       271
        
                 mv "$executablePath" "$oldExe"

     

       272
       272
        
               fi

     

       273
       273
        
       

     

       274
       274
       +
               # make xdg-open overrideable at runtime

     

       274
       275
        
               makeWrapper "$oldExe" \

     

       275
       276
        
                 "''${executablePath}${nameSuffix}" \

     

       276
       277
        
                   --prefix LD_LIBRARY_PATH ':' "$libs" \

     

       277
       278
        
                   --suffix-each GTK_PATH ':' "$gtk_modules" \

     

       278
       278
       -
                   --prefix PATH ':' "${xdg-utils}/bin" \

     

       279
       279
       +
                   --suffix PATH ':' "${xdg-utils}/bin" \

     

       279
       280
        
                   --suffix PATH ':' "$out/bin" \

     

       280
       281
        
                   --set MOZ_APP_LAUNCHER "${launcherName}" \

     

       281
       282
        
                   --set MOZ_SYSTEM_DIR "$out/lib/mozilla" \

+2 -1

pkgs/applications/networking/browsers/google-chrome/default.nix

···

       63
       63
        
           dbus gdk-pixbuf gcc-unwrapped.lib

     

       64
       64
        
           systemd

     

       65
       65
        
           libexif pciutils

     

       66
       66
       -
           liberation_ttf curl util-linux xdg-utils wget

     

       66
       66
       +
           liberation_ttf curl util-linux wget

     

       67
       67
        
           flac harfbuzz icu libpng opusWithCustomModes snappy speechd

     

       68
       68
        
           bzip2 libcap at-spi2-atk at-spi2-core

     

       69
       69
        
           libkrb5 libdrm libglvnd mesa coreutils

     
···

       145
       145
        
           makeWrapper "$out/share/google/$appname/google-$appname" "$exe" \

     

       146
       146
        
             --prefix LD_LIBRARY_PATH : "$rpath" \

     

       147
       147
        
             --prefix PATH            : "$binpath" \

     

       148
       148
       +
             --suffix PATH            : "${lib.makeBinPath [ xdg-utils ]}" \

     

       148
       149
        
             --prefix XDG_DATA_DIRS   : "$XDG_ICON_DIRS:$GSETTINGS_SCHEMAS_PATH:${addOpenGLRunpath.driverLink}/share" \

     

       149
       150
        
             --set CHROME_WRAPPER  "google-chrome-$dist" \

     

       150
       151
        
             --add-flags ${escapeShellArg commandLineArgs} \

+2 -2

pkgs/applications/networking/browsers/vivaldi/default.nix

···

       20
       20
        
         vivaldiName = if isSnapshot then "vivaldi-snapshot" else "vivaldi";

     

       21
       21
        
       in stdenv.mkDerivation rec {

     

       22
       22
        
         pname = "vivaldi";

     

       23
       23
       -
         version = "5.4.2753.33-1";

     

       23
       23
       +
         version = "5.4.2753.37-1";

     

       24
       24
        
       

     

       25
       25
        
         src = fetchurl {

     

       26
       26
        
           url = "https://downloads.vivaldi.com/${branch}/vivaldi-${branch}_${version}_amd64.deb";

     

       27
       27
       -
           sha256 = "0bs6324m5l5vmg1x1sj6g3qb1958c5c8z35r87r3rpnv52lqr501";

     

       27
       27
       +
           sha256 = "05aaprv1bqnb7iml1m6vlzv038dizy05ycwkrgb5nw1wiz9w6cyw";

     

       28
       28
        
         };

     

       29
       29
        
       

     

       30
       30
        
         unpackPhase = ''

+1 -1

pkgs/applications/networking/instant-messengers/armcord/default.nix

···

       108
       108
        
           # Wrap the startup command

     

       109
       109
        
           makeWrapper $out/opt/ArmCord/armcord $out/bin/armcord \

     

       110
       110
        
             --prefix LD_LIBRARY_PATH : "${lib.makeLibraryPath buildInputs}" \

     

       111
       111
       -
             --prefix PATH : ${lib.makeBinPath [ xdg-utils ]} \

     

       111
       111
       +
             --suffix PATH : ${lib.makeBinPath [ xdg-utils ]} \

     

       112
       112
        
             "''${gappsWrapperArgs[@]}"

     

       113
       113
        
       

     

       114
       114
        
           # Fix desktop link

+2 -1

pkgs/applications/networking/instant-messengers/bluejeans/default.nix

···

       111
       111
        
       

     

       112
       112
        
           cc $localtime64_stub -shared -o "${placeholder "out"}"/opt/BlueJeans/liblocaltime64_stub.so

     

       113
       113
        
       

     

       114
       114
       +
           # make xdg-open overrideable at runtime

     

       114
       115
        
           makeWrapper $out/opt/BlueJeans/bluejeans-v2 $out/bin/bluejeans \

     

       115
       116
        
             --set LD_LIBRARY_PATH "${libPath}":"${placeholder "out"}"/opt/BlueJeans \

     

       116
       117
        
             --set LD_PRELOAD "$out"/opt/BlueJeans/liblocaltime64_stub.so \

     

       117
       117
       -
             --prefix PATH : ${lib.makeBinPath [ xdg-utils ]}

     

       118
       118
       +
             --suffix PATH : ${lib.makeBinPath [ xdg-utils ]}

     

       118
       119
        
       

     

       119
       120
        
           substituteInPlace "$out"/share/applications/bluejeans-v2.desktop \

     

       120
       121
        
             --replace "/opt/BlueJeans/bluejeans-v2" "$out/bin/bluejeans"

+2 -1

pkgs/applications/networking/instant-messengers/franz/generic.nix

···

       85
       85
        
         dontWrapGApps = true;

     

       86
       86
        
       

     

       87
       87
        
         postFixup = ''

     

       88
       88
       +
           # make xdg-open overrideable at runtime

     

       88
       89
        
           wrapProgram $out/opt/${name}/${pname} \

     

       89
       90
        
             --prefix LD_LIBRARY_PATH : "${lib.makeLibraryPath runtimeDependencies}" \

     

       90
       90
       -
             --prefix PATH : ${xdg-utils}/bin \

     

       91
       91
       +
             --suffix PATH : ${xdg-utils}/bin \

     

       91
       92
        
             "''${gappsWrapperArgs[@]}"

     

       92
       93
        
         '';

     

       93
       94
        
       }

+3 -2

pkgs/applications/networking/instant-messengers/slack/default.nix

···

       164
       164
        
               patchelf --set-rpath ${rpath}:$out/lib/slack $file || true

     

       165
       165
        
             done

     

       166
       166
        
       

     

       167
       167
       -
             # Replace the broken bin/slack symlink with a startup wrapper

     

       167
       167
       +
             # Replace the broken bin/slack symlink with a startup wrapper.

     

       168
       168
       +
             # Make xdg-open overrideable at runtime.

     

       168
       169
        
             rm $out/bin/slack

     

       169
       170
        
             makeWrapper $out/lib/slack/slack $out/bin/slack \

     

       170
       171
        
               --prefix XDG_DATA_DIRS : $GSETTINGS_SCHEMAS_PATH \

     

       171
       171
       -
               --prefix PATH : ${lib.makeBinPath [xdg-utils]} \

     

       172
       172
       +
               --suffix PATH : ${lib.makeBinPath [xdg-utils]} \

     

       172
       173
        
               --add-flags "\''${NIXOS_OZONE_WL:+\''${WAYLAND_DISPLAY:+--enable-features=UseOzonePlatform --ozone-platform=wayland}}"

     

       173
       174
        
       

     

       174
       175
        
             # Fix the desktop link

+1 -1

pkgs/applications/networking/instant-messengers/telegram/tdesktop/default.nix

···

       173
       173
        
           wrapProgram $out/bin/telegram-desktop \

     

       174
       174
        
             "''${gappsWrapperArgs[@]}" \

     

       175
       175
        
             "''${qtWrapperArgs[@]}" \

     

       176
       176
       -
             --prefix PATH : ${lib.makeBinPath [ xdg-utils]} \

     

       176
       176
       +
             --suffix PATH : ${lib.makeBinPath [ xdg-utils]} \

     

       177
       177
        
             --set XDG_RUNTIME_DIR "XDG-RUNTIME-DIR"

     

       178
       178
        
           sed -i $out/bin/telegram-desktop \

     

       179
       179
        
             -e "s,'XDG-RUNTIME-DIR',\"\''${XDG_RUNTIME_DIR:-/run/user/\$(id --user)}\","

+2 -1

pkgs/applications/networking/instant-messengers/wavebox/default.nix

···

       53
       53
        
         '';

     

       54
       54
        
       

     

       55
       55
        
         postFixup = ''

     

       56
       56
       +
           # make xdg-open overrideable at runtime

     

       56
       57
        
           makeWrapper $out/opt/wavebox/Wavebox $out/bin/wavebox \

     

       57
       57
       -
             --prefix PATH : ${xdg-utils}/bin

     

       58
       58
       +
             --suffix PATH : ${xdg-utils}/bin

     

       58
       59
        
         '';

     

       59
       60
        
       

     

       60
       61
        
         meta = with lib; {

+265 -265

pkgs/applications/networking/mailreaders/thunderbird-bin/release_sources.nix

···

       1
       1
        
       {

     

       2
       2
       -
         version = "102.0.3";

     

       2
       2
       +
         version = "102.1.2";

     

       3
       3
        
         sources = [

     

       4
       4
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/af/thunderbird-102.0.3.tar.bz2";

     

       4
       4
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/af/thunderbird-102.1.2.tar.bz2";

     

       5
       5
        
             locale = "af";

     

       6
       6
        
             arch = "linux-x86_64";

     

       7
       7
       -
             sha256 = "acbb0b0467c0f83179c301e6435d6fb09d784d793bf56eb9d10a2240f40972cf";

     

       7
       7
       +
             sha256 = "045a2ae8a4da72b4ebe18800b03a5a5f722fcf2a26a3fb382b4412f5be1958bf";

     

       8
       8
        
           }

     

       9
       9
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/ar/thunderbird-102.0.3.tar.bz2";

     

       9
       9
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/ar/thunderbird-102.1.2.tar.bz2";

     

       10
       10
        
             locale = "ar";

     

       11
       11
        
             arch = "linux-x86_64";

     

       12
       12
       -
             sha256 = "c15a7753c36d20da261a4819a49429196d839a7288b756478330bcf69cd93611";

     

       12
       12
       +
             sha256 = "5d3b5ef861ef742025be92e49233b6f1ed91ae5bbc19e4819cfc68ad139663a7";

     

       13
       13
        
           }

     

       14
       14
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/ast/thunderbird-102.0.3.tar.bz2";

     

       14
       14
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/ast/thunderbird-102.1.2.tar.bz2";

     

       15
       15
        
             locale = "ast";

     

       16
       16
        
             arch = "linux-x86_64";

     

       17
       17
       -
             sha256 = "2e0747bfa96640d8c4998d08b3e1096797d870773bc805a2d9726da110799e35";

     

       17
       17
       +
             sha256 = "8a9255162105f0148aa12a5833a5a27294dcc5dd48841d871808031bf08d0e64";

     

       18
       18
        
           }

     

       19
       19
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/be/thunderbird-102.0.3.tar.bz2";

     

       19
       19
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/be/thunderbird-102.1.2.tar.bz2";

     

       20
       20
        
             locale = "be";

     

       21
       21
        
             arch = "linux-x86_64";

     

       22
       22
       -
             sha256 = "1316efa7b999c1ecd6470520ae90beec9575e549bd1735ea523bb61b1edc3230";

     

       22
       22
       +
             sha256 = "b46b07e20417ea588645893d3aa256acabf1689bb226e439983c55d99049dbab";

     

       23
       23
        
           }

     

       24
       24
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/bg/thunderbird-102.0.3.tar.bz2";

     

       24
       24
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/bg/thunderbird-102.1.2.tar.bz2";

     

       25
       25
        
             locale = "bg";

     

       26
       26
        
             arch = "linux-x86_64";

     

       27
       27
       -
             sha256 = "502f8aef0eab71e3b07404e888962930d3fd751d4402c178ed4ab2b38b1f9fb4";

     

       27
       27
       +
             sha256 = "090e8d450209b3584cf77bbe304c914d903be40491113d8667126cc7607d0ae2";

     

       28
       28
        
           }

     

       29
       29
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/br/thunderbird-102.0.3.tar.bz2";

     

       29
       29
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/br/thunderbird-102.1.2.tar.bz2";

     

       30
       30
        
             locale = "br";

     

       31
       31
        
             arch = "linux-x86_64";

     

       32
       32
       -
             sha256 = "1d3ec6f206083eca2b72f65bf50134163f58e800607e768892765f040feea94b";

     

       32
       32
       +
             sha256 = "b5aebf8f6210a2234041cc8774ff94459c38da193abfc222ae2994bba1f9b5b5";

     

       33
       33
        
           }

     

       34
       34
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/ca/thunderbird-102.0.3.tar.bz2";

     

       34
       34
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/ca/thunderbird-102.1.2.tar.bz2";

     

       35
       35
        
             locale = "ca";

     

       36
       36
        
             arch = "linux-x86_64";

     

       37
       37
       -
             sha256 = "aaae5de848334d5ebc3f761ec6780aa9826e43424308c256d40469c63699b6cc";

     

       37
       37
       +
             sha256 = "67e6fc3cd2a4ba0ba9b4a45cf4acc7a3cded9dea42a4e2826f06a750739a61ab";

     

       38
       38
        
           }

     

       39
       39
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/cak/thunderbird-102.0.3.tar.bz2";

     

       39
       39
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/cak/thunderbird-102.1.2.tar.bz2";

     

       40
       40
        
             locale = "cak";

     

       41
       41
        
             arch = "linux-x86_64";

     

       42
       42
       -
             sha256 = "f391f7d47c1fd9cb5ad7f5e1d79e20400521449404842cedaa7e5ac613e71e10";

     

       42
       42
       +
             sha256 = "bba56f6fbeb8441df134eb4a3179a6e95494e55feda1f8e697e7d1d8c45cbfc5";

     

       43
       43
        
           }

     

       44
       44
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/cs/thunderbird-102.0.3.tar.bz2";

     

       44
       44
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/cs/thunderbird-102.1.2.tar.bz2";

     

       45
       45
        
             locale = "cs";

     

       46
       46
        
             arch = "linux-x86_64";

     

       47
       47
       -
             sha256 = "9ba13380b2ac7c54f15e294fdd1534eb6687056865dad5f72aa4c7120fb2740b";

     

       47
       47
       +
             sha256 = "d6d586b4c28f189006928605537e73d33d4e6f3cb2cac7762961d300f180d7b7";

     

       48
       48
        
           }

     

       49
       49
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/cy/thunderbird-102.0.3.tar.bz2";

     

       49
       49
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/cy/thunderbird-102.1.2.tar.bz2";

     

       50
       50
        
             locale = "cy";

     

       51
       51
        
             arch = "linux-x86_64";

     

       52
       52
       -
             sha256 = "3f93b8fbe6cb9928a546768fbf0976b69361fd1ca34acc207b74a267cab32b7b";

     

       52
       52
       +
             sha256 = "80bedee4129f6ad3cbe452ffd744ae1273d230bff6b5ea1a149f7884f6c3a856";

     

       53
       53
        
           }

     

       54
       54
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/da/thunderbird-102.0.3.tar.bz2";

     

       54
       54
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/da/thunderbird-102.1.2.tar.bz2";

     

       55
       55
        
             locale = "da";

     

       56
       56
        
             arch = "linux-x86_64";

     

       57
       57
       -
             sha256 = "45a5500cad37d4a50ae16801362a1b32f4233f9febd2400deb239e082fd59421";

     

       57
       57
       +
             sha256 = "fe828dcd369eecce999dcada43703e7ae64f40d65e1a527aa1c8b5a12872da4b";

     

       58
       58
        
           }

     

       59
       59
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/de/thunderbird-102.0.3.tar.bz2";

     

       59
       59
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/de/thunderbird-102.1.2.tar.bz2";

     

       60
       60
        
             locale = "de";

     

       61
       61
        
             arch = "linux-x86_64";

     

       62
       62
       -
             sha256 = "4b36a09e6945c0a4674982e726ceaccf7b7724d9f394640f190ab0b2597cff4c";

     

       62
       62
       +
             sha256 = "c1caf3070b417ef809203a4da6bf93cdc328a9b240304ea609b52f707627bb69";

     

       63
       63
        
           }

     

       64
       64
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/dsb/thunderbird-102.0.3.tar.bz2";

     

       64
       64
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/dsb/thunderbird-102.1.2.tar.bz2";

     

       65
       65
        
             locale = "dsb";

     

       66
       66
        
             arch = "linux-x86_64";

     

       67
       67
       -
             sha256 = "3ab10a155916f89c803738fcac21a66b670321795b2aed813d3007e34f00b996";

     

       67
       67
       +
             sha256 = "8c3c81ad3b6067d51261aed574a6fd9df2188e6533540794763d6d58cf323849";

     

       68
       68
        
           }

     

       69
       69
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/el/thunderbird-102.0.3.tar.bz2";

     

       69
       69
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/el/thunderbird-102.1.2.tar.bz2";

     

       70
       70
        
             locale = "el";

     

       71
       71
        
             arch = "linux-x86_64";

     

       72
       72
       -
             sha256 = "2bcdedd483a0724714e20416fe4ff57d5f8d7e07da32e54430ab1af20a6f6089";

     

       72
       72
       +
             sha256 = "81ad4bc8a3d1fc7da97bb8655b12363c2a4033f39ece73ba37097315b6df0c70";

     

       73
       73
        
           }

     

       74
       74
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/en-CA/thunderbird-102.0.3.tar.bz2";

     

       74
       74
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/en-CA/thunderbird-102.1.2.tar.bz2";

     

       75
       75
        
             locale = "en-CA";

     

       76
       76
        
             arch = "linux-x86_64";

     

       77
       77
       -
             sha256 = "0b5bc27fd53c7b19a81d0dd502866237e0861770cc8e7caba5b5771b5321cdf3";

     

       77
       77
       +
             sha256 = "3487c91dc802bb0c284bd87dfaddd2aac907aca7ed9bcdde8d8d74d79a51eea9";

     

       78
       78
        
           }

     

       79
       79
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/en-GB/thunderbird-102.0.3.tar.bz2";

     

       79
       79
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/en-GB/thunderbird-102.1.2.tar.bz2";

     

       80
       80
        
             locale = "en-GB";

     

       81
       81
        
             arch = "linux-x86_64";

     

       82
       82
       -
             sha256 = "4bd0315b1b1f8d9d83e91b845df10807274c3ee921551fdece8a25cf51db08f2";

     

       82
       82
       +
             sha256 = "631f9c56e3b9dd3d606cf031a432c05f84c333c47067649264fd35e295d00910";

     

       83
       83
        
           }

     

       84
       84
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/en-US/thunderbird-102.0.3.tar.bz2";

     

       84
       84
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/en-US/thunderbird-102.1.2.tar.bz2";

     

       85
       85
        
             locale = "en-US";

     

       86
       86
        
             arch = "linux-x86_64";

     

       87
       87
       -
             sha256 = "16c2db5a24db5f9a7b449a73ebe0b881fd6965c4060f9b005df2ec819dded4e0";

     

       87
       87
       +
             sha256 = "5227881c30d9723386a9296c44c5253fe930c2f32b094c63972e4ba3a6c316eb";

     

       88
       88
        
           }

     

       89
       89
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/es-AR/thunderbird-102.0.3.tar.bz2";

     

       89
       89
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/es-AR/thunderbird-102.1.2.tar.bz2";

     

       90
       90
        
             locale = "es-AR";

     

       91
       91
        
             arch = "linux-x86_64";

     

       92
       92
       -
             sha256 = "a9cb0bbc9ea7cfe759cf19e9e27cf23ca88967d26e7a951a5b58908fdd535cdc";

     

       92
       92
       +
             sha256 = "094652b5b87bfe24389ef15acdb8a62b2bdee5b16d0ea3fa8b10b47ea8371391";

     

       93
       93
        
           }

     

       94
       94
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/es-ES/thunderbird-102.0.3.tar.bz2";

     

       94
       94
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/es-ES/thunderbird-102.1.2.tar.bz2";

     

       95
       95
        
             locale = "es-ES";

     

       96
       96
        
             arch = "linux-x86_64";

     

       97
       97
       -
             sha256 = "462ebc50ec7fb4a4f6fe81fcec48d2e50ae6ae0c90768499104692fdd5e78396";

     

       97
       97
       +
             sha256 = "63fa635cfc4e0d1c1365589090a1d01025f4b03d826f09530876329d23ab3f8f";

     

       98
       98
        
           }

     

       99
       99
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/es-MX/thunderbird-102.0.3.tar.bz2";

     

       99
       99
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/es-MX/thunderbird-102.1.2.tar.bz2";

     

       100
       100
        
             locale = "es-MX";

     

       101
       101
        
             arch = "linux-x86_64";

     

       102
       102
       -
             sha256 = "bb025a6d3bda7916ecba63b400386fa046d0a075ad1f82213d7b6577d6605edc";

     

       102
       102
       +
             sha256 = "efa60acc622b904efbf99f8708f236221f474da529741da7ae411300c0a839ac";

     

       103
       103
        
           }

     

       104
       104
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/et/thunderbird-102.0.3.tar.bz2";

     

       104
       104
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/et/thunderbird-102.1.2.tar.bz2";

     

       105
       105
        
             locale = "et";

     

       106
       106
        
             arch = "linux-x86_64";

     

       107
       107
       -
             sha256 = "7914cf39516159f769f29ca73985ae45d587c8db953fea10aa9814d65bbc341d";

     

       107
       107
       +
             sha256 = "c9eb969de36dddd32eca24c9845093caa9afffaba2e22e1c84ca8b1a1c39850f";

     

       108
       108
        
           }

     

       109
       109
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/eu/thunderbird-102.0.3.tar.bz2";

     

       109
       109
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/eu/thunderbird-102.1.2.tar.bz2";

     

       110
       110
        
             locale = "eu";

     

       111
       111
        
             arch = "linux-x86_64";

     

       112
       112
       -
             sha256 = "b34813f880a4a48152695a65d5ff24e206e34bdbdaeb8edef59c0075d3b130de";

     

       112
       112
       +
             sha256 = "65348b4703f68daa83f2964593c38fda497fe2426472138bdbc5c7a7eb48f348";

     

       113
       113
        
           }

     

       114
       114
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/fi/thunderbird-102.0.3.tar.bz2";

     

       114
       114
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/fi/thunderbird-102.1.2.tar.bz2";

     

       115
       115
        
             locale = "fi";

     

       116
       116
        
             arch = "linux-x86_64";

     

       117
       117
       -
             sha256 = "33aff0a00102765d0e102eea520f615a3d4d0f1d93a00e8768e6fc93492fd16e";

     

       117
       117
       +
             sha256 = "a229d9e9d7ea87e940d2aff60b0ee8e0288d3e584b0c73a45d1bb34d16d57117";

     

       118
       118
        
           }

     

       119
       119
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/fr/thunderbird-102.0.3.tar.bz2";

     

       119
       119
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/fr/thunderbird-102.1.2.tar.bz2";

     

       120
       120
        
             locale = "fr";

     

       121
       121
        
             arch = "linux-x86_64";

     

       122
       122
       -
             sha256 = "0cce5a940d8c3a2b9d15d3102108d21c3165d69c30a62618da0a93b95a52cf99";

     

       122
       122
       +
             sha256 = "714f5aefaab686cf6daa699f4e00455e2a4abf2414b5bbf3436e9020694ed27d";

     

       123
       123
        
           }

     

       124
       124
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/fy-NL/thunderbird-102.0.3.tar.bz2";

     

       124
       124
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/fy-NL/thunderbird-102.1.2.tar.bz2";

     

       125
       125
        
             locale = "fy-NL";

     

       126
       126
        
             arch = "linux-x86_64";

     

       127
       127
       -
             sha256 = "bba6ccedface111987459a370352972853fd0af65a61a1a0032faf24113730df";

     

       127
       127
       +
             sha256 = "89198e512ee6a8384a95739f718b89b3309b51c2afbe3f86841724e829990d05";

     

       128
       128
        
           }

     

       129
       129
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/ga-IE/thunderbird-102.0.3.tar.bz2";

     

       129
       129
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/ga-IE/thunderbird-102.1.2.tar.bz2";

     

       130
       130
        
             locale = "ga-IE";

     

       131
       131
        
             arch = "linux-x86_64";

     

       132
       132
       -
             sha256 = "18960a121ffc43f27e9fa733ec2a80881f4ca9316bf6114ccc693de772416c89";

     

       132
       132
       +
             sha256 = "4b68b313a633aab863abad1ebf80385a8a2bc95915ce74b7277e9bd6ec95fba0";

     

       133
       133
        
           }

     

       134
       134
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/gd/thunderbird-102.0.3.tar.bz2";

     

       134
       134
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/gd/thunderbird-102.1.2.tar.bz2";

     

       135
       135
        
             locale = "gd";

     

       136
       136
        
             arch = "linux-x86_64";

     

       137
       137
       -
             sha256 = "6e4430667839fbab52acc968036d9a08d99eec0eed5ceb5284ac747c4026c5ff";

     

       137
       137
       +
             sha256 = "8703b7388f1f183707682dc9f29d847a56a3e61b8018361e583bdb2081d0a92e";

     

       138
       138
        
           }

     

       139
       139
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/gl/thunderbird-102.0.3.tar.bz2";

     

       139
       139
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/gl/thunderbird-102.1.2.tar.bz2";

     

       140
       140
        
             locale = "gl";

     

       141
       141
        
             arch = "linux-x86_64";

     

       142
       142
       -
             sha256 = "0c871f1f195fc35b78c9f6b1f93220635231f117da3c5b470b852724408390e9";

     

       142
       142
       +
             sha256 = "f46a7c1a5e6d6b413220b2edcd8d0e9c3d0ebb7fe55599b3f151e8b82d0d0d6f";

     

       143
       143
        
           }

     

       144
       144
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/he/thunderbird-102.0.3.tar.bz2";

     

       144
       144
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/he/thunderbird-102.1.2.tar.bz2";

     

       145
       145
        
             locale = "he";

     

       146
       146
        
             arch = "linux-x86_64";

     

       147
       147
       -
             sha256 = "e0f6dc98cebe0a00361b05292547d338d767837b5a29740786049f0af9bdbf38";

     

       147
       147
       +
             sha256 = "cb79bc77109b9e36874755f497ff55e7df29dd45a411df134e342efae4df91a0";

     

       148
       148
        
           }

     

       149
       149
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/hr/thunderbird-102.0.3.tar.bz2";

     

       149
       149
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/hr/thunderbird-102.1.2.tar.bz2";

     

       150
       150
        
             locale = "hr";

     

       151
       151
        
             arch = "linux-x86_64";

     

       152
       152
       -
             sha256 = "af6a7cd558d9ce3f30c98fc1f6d4d5ffab8342dbab27b381943f8d21aab05f37";

     

       152
       152
       +
             sha256 = "f7f83473148269479dfa94211c3465e2dfb1e746a61c749d8a4648e37790832f";

     

       153
       153
        
           }

     

       154
       154
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/hsb/thunderbird-102.0.3.tar.bz2";

     

       154
       154
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/hsb/thunderbird-102.1.2.tar.bz2";

     

       155
       155
        
             locale = "hsb";

     

       156
       156
        
             arch = "linux-x86_64";

     

       157
       157
       -
             sha256 = "fc121b9b7ff2a74562dd239345d8754b3f21d5ea99eea47eee2436c71aad39fe";

     

       157
       157
       +
             sha256 = "f26ebf4f971502b6a5681b6888a65b4dbbd49bc7e44d99b2580bdad1e656be44";

     

       158
       158
        
           }

     

       159
       159
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/hu/thunderbird-102.0.3.tar.bz2";

     

       159
       159
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/hu/thunderbird-102.1.2.tar.bz2";

     

       160
       160
        
             locale = "hu";

     

       161
       161
        
             arch = "linux-x86_64";

     

       162
       162
       -
             sha256 = "e8df28798a07a4a43265f5a8c29ae0844f083f51bffe54afc9b173881407021b";

     

       162
       162
       +
             sha256 = "d05150adc28458e01b52a45d633ce895713bc4fbbc1a867bf61efa4459682fc2";

     

       163
       163
        
           }

     

       164
       164
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/hy-AM/thunderbird-102.0.3.tar.bz2";

     

       164
       164
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/hy-AM/thunderbird-102.1.2.tar.bz2";

     

       165
       165
        
             locale = "hy-AM";

     

       166
       166
        
             arch = "linux-x86_64";

     

       167
       167
       -
             sha256 = "8a7c705633a98937550b8c22199dfba8f9908fd6ea2c41cccf504bcb8c1b0c05";

     

       167
       167
       +
             sha256 = "bb2d7f8167dc30c1a927701022b927f6cd21aab4e60e02cee8274badb196c77c";

     

       168
       168
        
           }

     

       169
       169
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/id/thunderbird-102.0.3.tar.bz2";

     

       169
       169
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/id/thunderbird-102.1.2.tar.bz2";

     

       170
       170
        
             locale = "id";

     

       171
       171
        
             arch = "linux-x86_64";

     

       172
       172
       -
             sha256 = "ed2d44255fc8d227a602743619b6bab606bbc17de96f90503c644347fa99cc58";

     

       172
       172
       +
             sha256 = "06342277629f9f42fb6a2ccaeed5421047cf2dec9dd912b0825ee9ffee2d1aba";

     

       173
       173
        
           }

     

       174
       174
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/is/thunderbird-102.0.3.tar.bz2";

     

       174
       174
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/is/thunderbird-102.1.2.tar.bz2";

     

       175
       175
        
             locale = "is";

     

       176
       176
        
             arch = "linux-x86_64";

     

       177
       177
       -
             sha256 = "309d47fece404ef7717d95cf0b4920be48ecee0b69c73a1431e7044fab5c46d2";

     

       177
       177
       +
             sha256 = "ffa8a785f1a7c5c670782e87d492c9d2831ede93c178b1038f8735484036f8be";

     

       178
       178
        
           }

     

       179
       179
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/it/thunderbird-102.0.3.tar.bz2";

     

       179
       179
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/it/thunderbird-102.1.2.tar.bz2";

     

       180
       180
        
             locale = "it";

     

       181
       181
        
             arch = "linux-x86_64";

     

       182
       182
       -
             sha256 = "e92bd95955e9e6964394d95dd6564956e14c618e73f9853a72473cc89f6e68b7";

     

       182
       182
       +
             sha256 = "97d0433d6c49d445006738fe43cccca9c76216e065b0d6f126eb50084f5ab265";

     

       183
       183
        
           }

     

       184
       184
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/ja/thunderbird-102.0.3.tar.bz2";

     

       184
       184
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/ja/thunderbird-102.1.2.tar.bz2";

     

       185
       185
        
             locale = "ja";

     

       186
       186
        
             arch = "linux-x86_64";

     

       187
       187
       -
             sha256 = "81299c0ccaf3dd52d92a081a828d01573bcfe7f821c7cb6d0697acb505591189";

     

       187
       187
       +
             sha256 = "d8f885cb04693fc9a079ac541350b03805ab053b5aa60e49b037ebdfd5532019";

     

       188
       188
        
           }

     

       189
       189
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/ka/thunderbird-102.0.3.tar.bz2";

     

       189
       189
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/ka/thunderbird-102.1.2.tar.bz2";

     

       190
       190
        
             locale = "ka";

     

       191
       191
        
             arch = "linux-x86_64";

     

       192
       192
       -
             sha256 = "8445a72ae12af5c11d56e0dc1d8bc3beb5c368386950b3815bc63c6b3ff48837";

     

       192
       192
       +
             sha256 = "e07636d63fc6b22ea1534022a7e1433da1a3ddc5a22dd0e9e2245f2a18d4bdd6";

     

       193
       193
        
           }

     

       194
       194
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/kab/thunderbird-102.0.3.tar.bz2";

     

       194
       194
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/kab/thunderbird-102.1.2.tar.bz2";

     

       195
       195
        
             locale = "kab";

     

       196
       196
        
             arch = "linux-x86_64";

     

       197
       197
       -
             sha256 = "c403ad18c89ba13550484a4cf83afd0e28c6a11dead70f4a40ad81e136b5c4a7";

     

       197
       197
       +
             sha256 = "a0a087c5bbdc1acf2ab45ba164ce3a390cb40496b5c82a8821fff9e23641a193";

     

       198
       198
        
           }

     

       199
       199
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/kk/thunderbird-102.0.3.tar.bz2";

     

       199
       199
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/kk/thunderbird-102.1.2.tar.bz2";

     

       200
       200
        
             locale = "kk";

     

       201
       201
        
             arch = "linux-x86_64";

     

       202
       202
       -
             sha256 = "924ddb7c862291732f58dd3e57b9a3b30e39eea24efc1a02a6226f580c6878ca";

     

       202
       202
       +
             sha256 = "97548dde66cc92df20e2f807e70d57a4a72b4a6f5ff18caecf26e218ac218ca5";

     

       203
       203
        
           }

     

       204
       204
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/ko/thunderbird-102.0.3.tar.bz2";

     

       204
       204
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/ko/thunderbird-102.1.2.tar.bz2";

     

       205
       205
        
             locale = "ko";

     

       206
       206
        
             arch = "linux-x86_64";

     

       207
       207
       -
             sha256 = "7663f31cc759cf0115a75bba540f57f6c64905c63d204825a5fc63ad6e274edd";

     

       207
       207
       +
             sha256 = "bc51227d4f7bfd5c45b0234da669d8b6998c2cf109fe298e6edac65a34df5b02";

     

       208
       208
        
           }

     

       209
       209
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/lt/thunderbird-102.0.3.tar.bz2";

     

       209
       209
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/lt/thunderbird-102.1.2.tar.bz2";

     

       210
       210
        
             locale = "lt";

     

       211
       211
        
             arch = "linux-x86_64";

     

       212
       212
       -
             sha256 = "039d08152f607f6a8190cdb306e37ec2434447c655e9a86a5703170a36116a4b";

     

       212
       212
       +
             sha256 = "438017e6f6f6dd71553a0248282dfe25922121af6c4b14fce45dd95defd3a519";

     

       213
       213
        
           }

     

       214
       214
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/lv/thunderbird-102.0.3.tar.bz2";

     

       214
       214
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/lv/thunderbird-102.1.2.tar.bz2";

     

       215
       215
        
             locale = "lv";

     

       216
       216
        
             arch = "linux-x86_64";

     

       217
       217
       -
             sha256 = "0f40dbd570823d52abf7739024f1dda2a52303b02edf63939b6a544f15231252";

     

       217
       217
       +
             sha256 = "4e631147ed90b5eaf92f9c324f85620e59b22d96d4dba225567d13123393713e";

     

       218
       218
        
           }

     

       219
       219
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/ms/thunderbird-102.0.3.tar.bz2";

     

       219
       219
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/ms/thunderbird-102.1.2.tar.bz2";

     

       220
       220
        
             locale = "ms";

     

       221
       221
        
             arch = "linux-x86_64";

     

       222
       222
       -
             sha256 = "6f8abab920d8755f94bbbaa151fa6400be664b7e6dedc57e7c94c0bb2dfc4752";

     

       222
       222
       +
             sha256 = "26046b38c260068dadb29d779a0a7a4a15fda0c5aba9ace9e078554d01f337e4";

     

       223
       223
        
           }

     

       224
       224
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/nb-NO/thunderbird-102.0.3.tar.bz2";

     

       224
       224
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/nb-NO/thunderbird-102.1.2.tar.bz2";

     

       225
       225
        
             locale = "nb-NO";

     

       226
       226
        
             arch = "linux-x86_64";

     

       227
       227
       -
             sha256 = "4938fe75b54544ff7888c6db0a52b94ab4d71af15cfe429d6420ace100f47f0d";

     

       227
       227
       +
             sha256 = "933a7042a64c0f730aeef00449f4b05ef1f72bf031c31f3f4348c57f75243ff1";

     

       228
       228
        
           }

     

       229
       229
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/nl/thunderbird-102.0.3.tar.bz2";

     

       229
       229
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/nl/thunderbird-102.1.2.tar.bz2";

     

       230
       230
        
             locale = "nl";

     

       231
       231
        
             arch = "linux-x86_64";

     

       232
       232
       -
             sha256 = "769484d34082d656720e92f737bc7b80c39685e74aefa3148e8988d54c3fb96e";

     

       232
       232
       +
             sha256 = "8a221cb6c2f308c8b1761e436ac69b3e4367afc5d0b0bafe8463a19605d23307";

     

       233
       233
        
           }

     

       234
       234
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/nn-NO/thunderbird-102.0.3.tar.bz2";

     

       234
       234
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/nn-NO/thunderbird-102.1.2.tar.bz2";

     

       235
       235
        
             locale = "nn-NO";

     

       236
       236
        
             arch = "linux-x86_64";

     

       237
       237
       -
             sha256 = "2f6628897a9dda07bbf8f0d5df020b073b081ebb5d77942f23a38900b56f0cc5";

     

       237
       237
       +
             sha256 = "ab4182c6d11c0c4deb3ce09608e2c8ef771400562f3dceaa1c41e6592d376bf5";

     

       238
       238
        
           }

     

       239
       239
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/pa-IN/thunderbird-102.0.3.tar.bz2";

     

       239
       239
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/pa-IN/thunderbird-102.1.2.tar.bz2";

     

       240
       240
        
             locale = "pa-IN";

     

       241
       241
        
             arch = "linux-x86_64";

     

       242
       242
       -
             sha256 = "d5381e984b7f180c743f1572ee156c9b23350eacf3cea6b005aa159022bcb5c5";

     

       242
       242
       +
             sha256 = "bb9a7c35ee2b73217a80c6a9fc05c9ddf41cedf04b4fe872c11959ee5e80e95c";

     

       243
       243
        
           }

     

       244
       244
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/pl/thunderbird-102.0.3.tar.bz2";

     

       244
       244
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/pl/thunderbird-102.1.2.tar.bz2";

     

       245
       245
        
             locale = "pl";

     

       246
       246
        
             arch = "linux-x86_64";

     

       247
       247
       -
             sha256 = "2322ce9c3979e01d3bad6af964b1917293a654fa24e1ae70413194e93ebc4016";

     

       247
       247
       +
             sha256 = "aa705ada7e847104cfffc8e67cf2261b0c546a0fb6522aae8288cb0332ef480b";

     

       248
       248
        
           }

     

       249
       249
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/pt-BR/thunderbird-102.0.3.tar.bz2";

     

       249
       249
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/pt-BR/thunderbird-102.1.2.tar.bz2";

     

       250
       250
        
             locale = "pt-BR";

     

       251
       251
        
             arch = "linux-x86_64";

     

       252
       252
       -
             sha256 = "c427e30ce35ae73c9f214aaccbd61880dc896f18619d85e81f166d068d01a107";

     

       252
       252
       +
             sha256 = "1871803eb0df4341aca0a5e49956fdaa5b8a180b1a9b5d4891a6b5145141f0fa";

     

       253
       253
        
           }

     

       254
       254
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/pt-PT/thunderbird-102.0.3.tar.bz2";

     

       254
       254
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/pt-PT/thunderbird-102.1.2.tar.bz2";

     

       255
       255
        
             locale = "pt-PT";

     

       256
       256
        
             arch = "linux-x86_64";

     

       257
       257
       -
             sha256 = "8593bd34d6c87882d38cb521bd7e64e698565376bc50198a840f48516d2d1473";

     

       257
       257
       +
             sha256 = "dde614c584721d3d0ac34f022000691d9138777f5bf016b1f73b50eaec5297e6";

     

       258
       258
        
           }

     

       259
       259
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/rm/thunderbird-102.0.3.tar.bz2";

     

       259
       259
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/rm/thunderbird-102.1.2.tar.bz2";

     

       260
       260
        
             locale = "rm";

     

       261
       261
        
             arch = "linux-x86_64";

     

       262
       262
       -
             sha256 = "8afd7611f7a3604fd1b720ca4fd8f91b46e43a905874d87ef1befaefcfb73c16";

     

       262
       262
       +
             sha256 = "748b3db1b3984cfaa6deb55ab14bae5001a43a44013a9f0533b20dfb0914a171";

     

       263
       263
        
           }

     

       264
       264
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/ro/thunderbird-102.0.3.tar.bz2";

     

       264
       264
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/ro/thunderbird-102.1.2.tar.bz2";

     

       265
       265
        
             locale = "ro";

     

       266
       266
        
             arch = "linux-x86_64";

     

       267
       267
       -
             sha256 = "322faa61dc5524d84fadbd57df1cf6a12631c12b02af79807f6c0042c2d7906a";

     

       267
       267
       +
             sha256 = "9ac16bcebfb28ab3f0eeec7504c62b8965d25d0d199b4e2f371feed0daf71298";

     

       268
       268
        
           }

     

       269
       269
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/ru/thunderbird-102.0.3.tar.bz2";

     

       269
       269
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/ru/thunderbird-102.1.2.tar.bz2";

     

       270
       270
        
             locale = "ru";

     

       271
       271
        
             arch = "linux-x86_64";

     

       272
       272
       -
             sha256 = "696b98e0a1309bb66355051a0dd507a323e16fd98425fe8fff9688625edd6669";

     

       272
       272
       +
             sha256 = "32db96e0aafba6a886e90c2adb89363aaf06b0a03abadca558cbd8c97051d41c";

     

       273
       273
        
           }

     

       274
       274
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/sk/thunderbird-102.0.3.tar.bz2";

     

       274
       274
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/sk/thunderbird-102.1.2.tar.bz2";

     

       275
       275
        
             locale = "sk";

     

       276
       276
        
             arch = "linux-x86_64";

     

       277
       277
       -
             sha256 = "4370208682ced071070f798a5f3f024a6a154e12150435550ddb96334dd773de";

     

       277
       277
       +
             sha256 = "7a16cbfa0944c6592285d26a9a88ddd4f7d3100af139bfc079aced2252e6564d";

     

       278
       278
        
           }

     

       279
       279
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/sl/thunderbird-102.0.3.tar.bz2";

     

       279
       279
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/sl/thunderbird-102.1.2.tar.bz2";

     

       280
       280
        
             locale = "sl";

     

       281
       281
        
             arch = "linux-x86_64";

     

       282
       282
       -
             sha256 = "c7b15cbd62fcc90503f16ca6cfccded4205cd2af058886f23435317b0f085425";

     

       282
       282
       +
             sha256 = "165468dc4a5a012e7d84d7cb5a83d0ebc907fe95581dc9faf838bfcdf7958f49";

     

       283
       283
        
           }

     

       284
       284
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/sq/thunderbird-102.0.3.tar.bz2";

     

       284
       284
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/sq/thunderbird-102.1.2.tar.bz2";

     

       285
       285
        
             locale = "sq";

     

       286
       286
        
             arch = "linux-x86_64";

     

       287
       287
       -
             sha256 = "e5827847a7d987fdc0484bdc70110213b1d3a1ee4ba8e0b10bcebfc39c9f3e5a";

     

       287
       287
       +
             sha256 = "7ada316a5bad8752666d7497365863589a5693a6f9579a7978aafea69ab95be8";

     

       288
       288
        
           }

     

       289
       289
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/sr/thunderbird-102.0.3.tar.bz2";

     

       289
       289
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/sr/thunderbird-102.1.2.tar.bz2";

     

       290
       290
        
             locale = "sr";

     

       291
       291
        
             arch = "linux-x86_64";

     

       292
       292
       -
             sha256 = "a17962cbf4cc6b302a7b06432fa9a5ba11e33505089619bb677293d6f3529832";

     

       292
       292
       +
             sha256 = "b7a3a141050b189051010a977bf85f27135f8ee10af0c70dcbe04780c7f05489";

     

       293
       293
        
           }

     

       294
       294
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/sv-SE/thunderbird-102.0.3.tar.bz2";

     

       294
       294
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/sv-SE/thunderbird-102.1.2.tar.bz2";

     

       295
       295
        
             locale = "sv-SE";

     

       296
       296
        
             arch = "linux-x86_64";

     

       297
       297
       -
             sha256 = "bb11f3928321898f0c746dc988995bf853e102f753b91c602073c8357cfb1d00";

     

       297
       297
       +
             sha256 = "35b058a42ca3627f9695eb22d1c8d71ee72aa4bc3be2e072aa9561cded1d6686";

     

       298
       298
        
           }

     

       299
       299
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/th/thunderbird-102.0.3.tar.bz2";

     

       299
       299
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/th/thunderbird-102.1.2.tar.bz2";

     

       300
       300
        
             locale = "th";

     

       301
       301
        
             arch = "linux-x86_64";

     

       302
       302
       -
             sha256 = "38696729272f4ca48d918767135e03a24226f86529d243482c729196d645f94b";

     

       302
       302
       +
             sha256 = "39cc0214918f882ed19b0986f500d7b24a29026b2651f35b798571460f3cf022";

     

       303
       303
        
           }

     

       304
       304
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/tr/thunderbird-102.0.3.tar.bz2";

     

       304
       304
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/tr/thunderbird-102.1.2.tar.bz2";

     

       305
       305
        
             locale = "tr";

     

       306
       306
        
             arch = "linux-x86_64";

     

       307
       307
       -
             sha256 = "3857970887245300da2d764a2da99a64fcdd725ae9456dbe423a79483666cd93";

     

       307
       307
       +
             sha256 = "b8f2d411457ce94ee48f98725f996098f3868406ba82ecd4a9305a17e42aaccf";

     

       308
       308
        
           }

     

       309
       309
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/uk/thunderbird-102.0.3.tar.bz2";

     

       309
       309
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/uk/thunderbird-102.1.2.tar.bz2";

     

       310
       310
        
             locale = "uk";

     

       311
       311
        
             arch = "linux-x86_64";

     

       312
       312
       -
             sha256 = "743b5f2b7e04af087acbf75ca47ea5ec9588530908a33c8e2025d1ee6d91b70e";

     

       312
       312
       +
             sha256 = "e41fb8cbe8da3f632992f4fd15e812b2e10e5ade070f3970446a213724b3736d";

     

       313
       313
        
           }

     

       314
       314
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/uz/thunderbird-102.0.3.tar.bz2";

     

       314
       314
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/uz/thunderbird-102.1.2.tar.bz2";

     

       315
       315
        
             locale = "uz";

     

       316
       316
        
             arch = "linux-x86_64";

     

       317
       317
       -
             sha256 = "ab498aa09a784ca8f42ecae1cfb7ed6b54afbf7381fc3f32391cf160983fdbc6";

     

       317
       317
       +
             sha256 = "26fdadcb748baf1c699a23fc90caa9cb342cf93bc18b110c6efcce89b3eb555a";

     

       318
       318
        
           }

     

       319
       319
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/vi/thunderbird-102.0.3.tar.bz2";

     

       319
       319
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/vi/thunderbird-102.1.2.tar.bz2";

     

       320
       320
        
             locale = "vi";

     

       321
       321
        
             arch = "linux-x86_64";

     

       322
       322
       -
             sha256 = "57d18f28b4ebe93093657aab133c58da1859ad8261fe5eb14f156a813c9feb53";

     

       322
       322
       +
             sha256 = "a91cf22c3592346599ede9495f51b0aac22823194f4ceb4d34b785dfd494d47d";

     

       323
       323
        
           }

     

       324
       324
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/zh-CN/thunderbird-102.0.3.tar.bz2";

     

       324
       324
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/zh-CN/thunderbird-102.1.2.tar.bz2";

     

       325
       325
        
             locale = "zh-CN";

     

       326
       326
        
             arch = "linux-x86_64";

     

       327
       327
       -
             sha256 = "7922f00281084e18f3a27f661c14730de81b7df0ed3052374ad6ee1f93d15ed3";

     

       327
       327
       +
             sha256 = "db5c8a102bd3038105f032339a055c7f859ba64ed5f013aeaabae66a5f9b7c97";

     

       328
       328
        
           }

     

       329
       329
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-x86_64/zh-TW/thunderbird-102.0.3.tar.bz2";

     

       329
       329
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-x86_64/zh-TW/thunderbird-102.1.2.tar.bz2";

     

       330
       330
        
             locale = "zh-TW";

     

       331
       331
        
             arch = "linux-x86_64";

     

       332
       332
       -
             sha256 = "c8119e17541bd649728d3fa4f725231ded11f37809048c5b20e8847b8c222ec5";

     

       332
       332
       +
             sha256 = "6eb7070f15f25eed3a4af81ac4d10444e9bf8fc16dcc20d1d0b2877ca508c3ad";

     

       333
       333
        
           }

     

       334
       334
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/af/thunderbird-102.0.3.tar.bz2";

     

       334
       334
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/af/thunderbird-102.1.2.tar.bz2";

     

       335
       335
        
             locale = "af";

     

       336
       336
        
             arch = "linux-i686";

     

       337
       337
       -
             sha256 = "dd728dbb96d781c4ad0b2a01d67807d2b8235c7b77f652b4d226248f84f2bb92";

     

       337
       337
       +
             sha256 = "0389d59440492dba14c4600618da93b1d6164c2942b160398ef48d2d33ff6afe";

     

       338
       338
        
           }

     

       339
       339
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/ar/thunderbird-102.0.3.tar.bz2";

     

       339
       339
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/ar/thunderbird-102.1.2.tar.bz2";

     

       340
       340
        
             locale = "ar";

     

       341
       341
        
             arch = "linux-i686";

     

       342
       342
       -
             sha256 = "68314d9ce2afc0a91578b7761df736b16d3016629ac191474a014e662bf4e419";

     

       342
       342
       +
             sha256 = "b1aa3d6f9bd3b124ebc81e4b7bd244e07267aa9fdb433a15cc55259678b65d59";

     

       343
       343
        
           }

     

       344
       344
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/ast/thunderbird-102.0.3.tar.bz2";

     

       344
       344
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/ast/thunderbird-102.1.2.tar.bz2";

     

       345
       345
        
             locale = "ast";

     

       346
       346
        
             arch = "linux-i686";

     

       347
       347
       -
             sha256 = "e9e82165023f075e6380794487474856ef0420530f94f8c1c233d3112fcc2ca5";

     

       347
       347
       +
             sha256 = "39557a3ff8b1b9f334fb60ba0f21f652eb052e2ce52ca69132c256ab18f36484";

     

       348
       348
        
           }

     

       349
       349
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/be/thunderbird-102.0.3.tar.bz2";

     

       349
       349
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/be/thunderbird-102.1.2.tar.bz2";

     

       350
       350
        
             locale = "be";

     

       351
       351
        
             arch = "linux-i686";

     

       352
       352
       -
             sha256 = "3722fc4b2a9f42104f4bb2267923320c392f817486c1dcfbe4a92c01764a900c";

     

       352
       352
       +
             sha256 = "c8ad677a9c20d462cca53030ef21708668fad7f6ca2432e48159cdc35b283416";

     

       353
       353
        
           }

     

       354
       354
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/bg/thunderbird-102.0.3.tar.bz2";

     

       354
       354
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/bg/thunderbird-102.1.2.tar.bz2";

     

       355
       355
        
             locale = "bg";

     

       356
       356
        
             arch = "linux-i686";

     

       357
       357
       -
             sha256 = "719f8571d79cdef43abba3bd2e453d875652b9bde7b24ed987cbb83b313e8cf0";

     

       357
       357
       +
             sha256 = "248fb0b4259c9936d0ab7246d49749d79cac136843393cfb42fb8fb1e60a3c4d";

     

       358
       358
        
           }

     

       359
       359
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/br/thunderbird-102.0.3.tar.bz2";

     

       359
       359
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/br/thunderbird-102.1.2.tar.bz2";

     

       360
       360
        
             locale = "br";

     

       361
       361
        
             arch = "linux-i686";

     

       362
       362
       -
             sha256 = "8195d158a2770707073ae0ed18bcf578ff061c052d593b4feb02e9f10facb6be";

     

       362
       362
       +
             sha256 = "4f7b9cb23ce763d4c80bbbfa55f37dc950c768620891a1540a4cd2c2add61120";

     

       363
       363
        
           }

     

       364
       364
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/ca/thunderbird-102.0.3.tar.bz2";

     

       364
       364
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/ca/thunderbird-102.1.2.tar.bz2";

     

       365
       365
        
             locale = "ca";

     

       366
       366
        
             arch = "linux-i686";

     

       367
       367
       -
             sha256 = "f97b5247b38c00f2e6db3a2edd878de0059dec8a59b92663ea2d9f7175a4eb7e";

     

       367
       367
       +
             sha256 = "95335a5eca928b64cfd3b66bc3fd04c013300122ebd6120d53fffa5450544532";

     

       368
       368
        
           }

     

       369
       369
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/cak/thunderbird-102.0.3.tar.bz2";

     

       369
       369
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/cak/thunderbird-102.1.2.tar.bz2";

     

       370
       370
        
             locale = "cak";

     

       371
       371
        
             arch = "linux-i686";

     

       372
       372
       -
             sha256 = "247f1be0ebac1033b519dadefb35c645c02c6352658a24e9b2864d449bc91ab3";

     

       372
       372
       +
             sha256 = "f70d912d44e5d86dc565ac1ea517178e1c02a054805a1fe2f46c0749bbc94327";

     

       373
       373
        
           }

     

       374
       374
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/cs/thunderbird-102.0.3.tar.bz2";

     

       374
       374
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/cs/thunderbird-102.1.2.tar.bz2";

     

       375
       375
        
             locale = "cs";

     

       376
       376
        
             arch = "linux-i686";

     

       377
       377
       -
             sha256 = "39bec8757b777aeadf5e3803a1b8ca52bf8c62f906d792b1d47a68b67593162f";

     

       377
       377
       +
             sha256 = "27ca0c7c25ea1eddda5416a8e79e21f5c56d11c58d25f7716f8aa5e7628dc3fd";

     

       378
       378
        
           }

     

       379
       379
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/cy/thunderbird-102.0.3.tar.bz2";

     

       379
       379
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/cy/thunderbird-102.1.2.tar.bz2";

     

       380
       380
        
             locale = "cy";

     

       381
       381
        
             arch = "linux-i686";

     

       382
       382
       -
             sha256 = "d9899c8f3b6c538828b559af3990d44bb93fa085539815f4c800bcd3f7f2029c";

     

       382
       382
       +
             sha256 = "24927b8410cef3c9ed234fe1ae4d264333e4d14577715580817117479d4039b5";

     

       383
       383
        
           }

     

       384
       384
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/da/thunderbird-102.0.3.tar.bz2";

     

       384
       384
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/da/thunderbird-102.1.2.tar.bz2";

     

       385
       385
        
             locale = "da";

     

       386
       386
        
             arch = "linux-i686";

     

       387
       387
       -
             sha256 = "359ffd538a7f5f2870d8bd379f1538800defe296766a0cae57432e545f0ee49e";

     

       387
       387
       +
             sha256 = "bf34f47b5397ba7abaf8df61deea65a28f61d66dc91502d41fec5f8593fecc75";

     

       388
       388
        
           }

     

       389
       389
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/de/thunderbird-102.0.3.tar.bz2";

     

       389
       389
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/de/thunderbird-102.1.2.tar.bz2";

     

       390
       390
        
             locale = "de";

     

       391
       391
        
             arch = "linux-i686";

     

       392
       392
       -
             sha256 = "1f372cd57db1e564d960c12dd34317747017d4255e2c5dc8f960d5075bf2a835";

     

       392
       392
       +
             sha256 = "372606ca06a8e86ec7d39f9da0d6943b1dac6389aa5223ceab572d7b17aef4e1";

     

       393
       393
        
           }

     

       394
       394
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/dsb/thunderbird-102.0.3.tar.bz2";

     

       394
       394
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/dsb/thunderbird-102.1.2.tar.bz2";

     

       395
       395
        
             locale = "dsb";

     

       396
       396
        
             arch = "linux-i686";

     

       397
       397
       -
             sha256 = "fca6872c8bc3fd832ceb96b4cabe189fb4b679592fbf4fd4e27df514da917d4e";

     

       397
       397
       +
             sha256 = "b771a808ed13d2e21b4411e3e1b22e0a4159593cdf2e5eb7aad37a19b58892dc";

     

       398
       398
        
           }

     

       399
       399
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/el/thunderbird-102.0.3.tar.bz2";

     

       399
       399
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/el/thunderbird-102.1.2.tar.bz2";

     

       400
       400
        
             locale = "el";

     

       401
       401
        
             arch = "linux-i686";

     

       402
       402
       -
             sha256 = "81ba36edd7ce98f44a86511fc7b03e030e2fc2ec1821640114a6546babc1b042";

     

       402
       402
       +
             sha256 = "da57fe1f356d9b26bf49289e4755e3faefa31f0719ff00f8af7e3b832bf59e4a";

     

       403
       403
        
           }

     

       404
       404
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/en-CA/thunderbird-102.0.3.tar.bz2";

     

       404
       404
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/en-CA/thunderbird-102.1.2.tar.bz2";

     

       405
       405
        
             locale = "en-CA";

     

       406
       406
        
             arch = "linux-i686";

     

       407
       407
       -
             sha256 = "bf3ec87dd0842e92d0a759e8bad1eb5fbce8917277fabfd70b8366bfab9f011f";

     

       407
       407
       +
             sha256 = "a4abeea1e5477fcdbb2a5606610eefeb40fdd65e6e418042058e684b86b2c30e";

     

       408
       408
        
           }

     

       409
       409
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/en-GB/thunderbird-102.0.3.tar.bz2";

     

       409
       409
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/en-GB/thunderbird-102.1.2.tar.bz2";

     

       410
       410
        
             locale = "en-GB";

     

       411
       411
        
             arch = "linux-i686";

     

       412
       412
       -
             sha256 = "9b1ac42adceab6ddc19bc432ae4568fe4008f0063c59b86871041a299890d9fe";

     

       412
       412
       +
             sha256 = "8ff8ca611dfdbd03b63eff740fa70c4fceeb292157af3718a79499b77d6954f7";

     

       413
       413
        
           }

     

       414
       414
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/en-US/thunderbird-102.0.3.tar.bz2";

     

       414
       414
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/en-US/thunderbird-102.1.2.tar.bz2";

     

       415
       415
        
             locale = "en-US";

     

       416
       416
        
             arch = "linux-i686";

     

       417
       417
       -
             sha256 = "acd7b35b5d7d2e863a0a37a850b60d6ce91d156476ce1c7974256339000d86bb";

     

       417
       417
       +
             sha256 = "5eb0b8c567be77cd8231ebab5269acbac310c2d01cf6f810c5e321496884b94c";

     

       418
       418
        
           }

     

       419
       419
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/es-AR/thunderbird-102.0.3.tar.bz2";

     

       419
       419
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/es-AR/thunderbird-102.1.2.tar.bz2";

     

       420
       420
        
             locale = "es-AR";

     

       421
       421
        
             arch = "linux-i686";

     

       422
       422
       -
             sha256 = "4b2715d15add631a1158e843108cbcc0eefce833ec42d7d35b4d856b473cb48f";

     

       422
       422
       +
             sha256 = "6e19e0ba0a54e175b5810a42a2f086a07be421dd6f6c227c60b870324042b2ca";

     

       423
       423
        
           }

     

       424
       424
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/es-ES/thunderbird-102.0.3.tar.bz2";

     

       424
       424
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/es-ES/thunderbird-102.1.2.tar.bz2";

     

       425
       425
        
             locale = "es-ES";

     

       426
       426
        
             arch = "linux-i686";

     

       427
       427
       -
             sha256 = "6b3dcd54b1e948ee36a3e674c22e56356b66503bd40e149b9a24ea3116cf98e5";

     

       427
       427
       +
             sha256 = "a626601734b040c32a1e54309799a6d953719a38eec731c6ef23b09d544c282c";

     

       428
       428
        
           }

     

       429
       429
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/es-MX/thunderbird-102.0.3.tar.bz2";

     

       429
       429
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/es-MX/thunderbird-102.1.2.tar.bz2";

     

       430
       430
        
             locale = "es-MX";

     

       431
       431
        
             arch = "linux-i686";

     

       432
       432
       -
             sha256 = "49fedc894cd933770536eea6359c31a01e47ad9e797274284bfaf3ea8de8ff15";

     

       432
       432
       +
             sha256 = "209a1a0b6d86301740846943ea62acd1781456210f3b5c3b9191017730a2dc72";

     

       433
       433
        
           }

     

       434
       434
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/et/thunderbird-102.0.3.tar.bz2";

     

       434
       434
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/et/thunderbird-102.1.2.tar.bz2";

     

       435
       435
        
             locale = "et";

     

       436
       436
        
             arch = "linux-i686";

     

       437
       437
       -
             sha256 = "78d961730172ae310bc08139d0eff9471745900d85fd8a568c97d649bca1b354";

     

       437
       437
       +
             sha256 = "9e4bb92b59ab36e317e38986c42a3231c18761a9fe6c3cc3aba7e672fc8c4334";

     

       438
       438
        
           }

     

       439
       439
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/eu/thunderbird-102.0.3.tar.bz2";

     

       439
       439
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/eu/thunderbird-102.1.2.tar.bz2";

     

       440
       440
        
             locale = "eu";

     

       441
       441
        
             arch = "linux-i686";

     

       442
       442
       -
             sha256 = "d8dbc084f38f86598cb1efe16a6c48634c57830318d9a9d1f5ac9ef7c63ef7ea";

     

       442
       442
       +
             sha256 = "68ed1a1137601c4f2f57e6afc146dc8700041b5c39931f1eb80b3c3807ab515e";

     

       443
       443
        
           }

     

       444
       444
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/fi/thunderbird-102.0.3.tar.bz2";

     

       444
       444
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/fi/thunderbird-102.1.2.tar.bz2";

     

       445
       445
        
             locale = "fi";

     

       446
       446
        
             arch = "linux-i686";

     

       447
       447
       -
             sha256 = "71d303185d5ec95d607507bb9836a01940908e27c15117575280b13dcb5788c0";

     

       447
       447
       +
             sha256 = "71fbf151a51727cd43f56dda7039442246bd6faa98a45ccef5c8b8c040315064";

     

       448
       448
        
           }

     

       449
       449
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/fr/thunderbird-102.0.3.tar.bz2";

     

       449
       449
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/fr/thunderbird-102.1.2.tar.bz2";

     

       450
       450
        
             locale = "fr";

     

       451
       451
        
             arch = "linux-i686";

     

       452
       452
       -
             sha256 = "55e158f1204517652d03e2b7d1600cee41f8c024db794f4676826f960440a6a4";

     

       452
       452
       +
             sha256 = "a2119c1e7e652d1f2423e62be999c70303fafe1498df31c74e9254f8f6b7a63d";

     

       453
       453
        
           }

     

       454
       454
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/fy-NL/thunderbird-102.0.3.tar.bz2";

     

       454
       454
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/fy-NL/thunderbird-102.1.2.tar.bz2";

     

       455
       455
        
             locale = "fy-NL";

     

       456
       456
        
             arch = "linux-i686";

     

       457
       457
       -
             sha256 = "329d42fef604eba4f3b5d036ba5b9acf055673205dd30f8651c94f5c7684bbf6";

     

       457
       457
       +
             sha256 = "6dc49239f5e7abfbd460e35d79872edf264911ebede3bbaed30f36af9ba16400";

     

       458
       458
        
           }

     

       459
       459
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/ga-IE/thunderbird-102.0.3.tar.bz2";

     

       459
       459
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/ga-IE/thunderbird-102.1.2.tar.bz2";

     

       460
       460
        
             locale = "ga-IE";

     

       461
       461
        
             arch = "linux-i686";

     

       462
       462
       -
             sha256 = "4c4d3de0d9db04caf2b46238c47c6b897f2d7fe52fe21cfa14d71568671dbf02";

     

       462
       462
       +
             sha256 = "e5faa22d057228ca0a982601469e2bb41a1782e61fac694b5ae458e74f84fe37";

     

       463
       463
        
           }

     

       464
       464
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/gd/thunderbird-102.0.3.tar.bz2";

     

       464
       464
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/gd/thunderbird-102.1.2.tar.bz2";

     

       465
       465
        
             locale = "gd";

     

       466
       466
        
             arch = "linux-i686";

     

       467
       467
       -
             sha256 = "f14761057f6d1d6934e5e1cc55335a46f26a2382dc4708632665265331b4f08b";

     

       467
       467
       +
             sha256 = "ea99f37e3310978ae95bd04b2dbfa8f7e7f4f2f7dc41c72df662c3778c9941a5";

     

       468
       468
        
           }

     

       469
       469
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/gl/thunderbird-102.0.3.tar.bz2";

     

       469
       469
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/gl/thunderbird-102.1.2.tar.bz2";

     

       470
       470
        
             locale = "gl";

     

       471
       471
        
             arch = "linux-i686";

     

       472
       472
       -
             sha256 = "2078e7499593799d76b2242f44c0097d5a1ec357da62802d5d1cce47732a75a3";

     

       472
       472
       +
             sha256 = "6bafaa93902648eb3964e0e1bbf6743fb4b4415e98e29b6f678ccfaf99a7120d";

     

       473
       473
        
           }

     

       474
       474
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/he/thunderbird-102.0.3.tar.bz2";

     

       474
       474
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/he/thunderbird-102.1.2.tar.bz2";

     

       475
       475
        
             locale = "he";

     

       476
       476
        
             arch = "linux-i686";

     

       477
       477
       -
             sha256 = "2fa1c357cfb849d61562bca9146939eda36f0af909022dbd21029b3c47f683ae";

     

       477
       477
       +
             sha256 = "3f7abb2eadbb725b5e2e3a71863b0ac5a2f5b2747d4f207c1cf712ba36d1d9ed";

     

       478
       478
        
           }

     

       479
       479
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/hr/thunderbird-102.0.3.tar.bz2";

     

       479
       479
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/hr/thunderbird-102.1.2.tar.bz2";

     

       480
       480
        
             locale = "hr";

     

       481
       481
        
             arch = "linux-i686";

     

       482
       482
       -
             sha256 = "c1b8fd464affaa87903856b9c959a09b120814d6887ce946db14e1f429a85304";

     

       482
       482
       +
             sha256 = "2dea47835e6b7b1c40148b449dceb993368558f9c8c40a9c5b4506a8409c9bb8";

     

       483
       483
        
           }

     

       484
       484
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/hsb/thunderbird-102.0.3.tar.bz2";

     

       484
       484
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/hsb/thunderbird-102.1.2.tar.bz2";

     

       485
       485
        
             locale = "hsb";

     

       486
       486
        
             arch = "linux-i686";

     

       487
       487
       -
             sha256 = "db8ac9b2463293d8360cb04df2a5a7c92f4b8eee7f1e705ca3b2f19031ff2d4e";

     

       487
       487
       +
             sha256 = "d58fab220f516fbf1a4e219b9d1e64882a7b1fbd905bc07b9930815857eab991";

     

       488
       488
        
           }

     

       489
       489
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/hu/thunderbird-102.0.3.tar.bz2";

     

       489
       489
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/hu/thunderbird-102.1.2.tar.bz2";

     

       490
       490
        
             locale = "hu";

     

       491
       491
        
             arch = "linux-i686";

     

       492
       492
       -
             sha256 = "3749911e71ef81a89a3009bf691c8a06abbc1ca537dedb68c785dca9f0257d4f";

     

       492
       492
       +
             sha256 = "40fd326287e681413b5631ffdfbbb07bae2aedd15d35f73c4dd0058fe622a315";

     

       493
       493
        
           }

     

       494
       494
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/hy-AM/thunderbird-102.0.3.tar.bz2";

     

       494
       494
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/hy-AM/thunderbird-102.1.2.tar.bz2";

     

       495
       495
        
             locale = "hy-AM";

     

       496
       496
        
             arch = "linux-i686";

     

       497
       497
       -
             sha256 = "07988301e82d78494e478fd5f99a0639642364bf53f8cd9711ff643112cf25c2";

     

       497
       497
       +
             sha256 = "2e3976460f2e49805fef9e455eb24647bb0a9c77f4302b8e1f9e7caf0a4f69dd";

     

       498
       498
        
           }

     

       499
       499
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/id/thunderbird-102.0.3.tar.bz2";

     

       499
       499
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/id/thunderbird-102.1.2.tar.bz2";

     

       500
       500
        
             locale = "id";

     

       501
       501
        
             arch = "linux-i686";

     

       502
       502
       -
             sha256 = "8af0ece3ba77f12ed9053ff9bcf311cebcf8159b34bded5df09748c2fbfb208a";

     

       502
       502
       +
             sha256 = "4d1782b347f631547902c4896eb809927e459e031cbadd69e561cec0d67f0be9";

     

       503
       503
        
           }

     

       504
       504
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/is/thunderbird-102.0.3.tar.bz2";

     

       504
       504
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/is/thunderbird-102.1.2.tar.bz2";

     

       505
       505
        
             locale = "is";

     

       506
       506
        
             arch = "linux-i686";

     

       507
       507
       -
             sha256 = "663b1af1fb3977edcb5524769effd6a94da93860c9c7206c4b31aadb85e5c8bf";

     

       507
       507
       +
             sha256 = "948dbf54d7a325500ad93fcb2664fe2a198defda12cc46ed9df60658c1dee3ef";

     

       508
       508
        
           }

     

       509
       509
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/it/thunderbird-102.0.3.tar.bz2";

     

       509
       509
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/it/thunderbird-102.1.2.tar.bz2";

     

       510
       510
        
             locale = "it";

     

       511
       511
        
             arch = "linux-i686";

     

       512
       512
       -
             sha256 = "83739d727628ef7b60c5732d41bb6c708d3adfa5fb2ccfbb0f1a62f4ac0317c5";

     

       512
       512
       +
             sha256 = "b8b56dbdeb2649473971d9b0dbfb759c615f300dda0484536083be1b9bfa0f9e";

     

       513
       513
        
           }

     

       514
       514
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/ja/thunderbird-102.0.3.tar.bz2";

     

       514
       514
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/ja/thunderbird-102.1.2.tar.bz2";

     

       515
       515
        
             locale = "ja";

     

       516
       516
        
             arch = "linux-i686";

     

       517
       517
       -
             sha256 = "79d20840657d20afbe7d1dcf5e86d26ded6e72a52d41b4433dbd7c08e77a239b";

     

       517
       517
       +
             sha256 = "156f2aada12af105f8751ebd15c9fe0e55e7c590e899eec1c45560d6ae36af80";

     

       518
       518
        
           }

     

       519
       519
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/ka/thunderbird-102.0.3.tar.bz2";

     

       519
       519
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/ka/thunderbird-102.1.2.tar.bz2";

     

       520
       520
        
             locale = "ka";

     

       521
       521
        
             arch = "linux-i686";

     

       522
       522
       -
             sha256 = "86b332459621f593e9f311b1b606e38923ad8862b4d0b6a35e113cda67ad4255";

     

       522
       522
       +
             sha256 = "2ef2f49658a117de9de1ac194b83efa3a3b2a30c64ddd6c9296f14c2618bc1ee";

     

       523
       523
        
           }

     

       524
       524
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/kab/thunderbird-102.0.3.tar.bz2";

     

       524
       524
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/kab/thunderbird-102.1.2.tar.bz2";

     

       525
       525
        
             locale = "kab";

     

       526
       526
        
             arch = "linux-i686";

     

       527
       527
       -
             sha256 = "9e4def077f06509440bc78d7ac2b7573c0e2140944bb0761d55472cb1a5465c8";

     

       527
       527
       +
             sha256 = "95b14e777593530ba764cfcc8c60726b41637b49801fdd22e9fb3c07e2abd84f";

     

       528
       528
        
           }

     

       529
       529
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/kk/thunderbird-102.0.3.tar.bz2";

     

       529
       529
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/kk/thunderbird-102.1.2.tar.bz2";

     

       530
       530
        
             locale = "kk";

     

       531
       531
        
             arch = "linux-i686";

     

       532
       532
       -
             sha256 = "39bc019264f03f7f8a25bb42242629af3c7971965b7a448f02f862e76087b7c4";

     

       532
       532
       +
             sha256 = "f032b6a3295b85512b68ab436b8b83dca63a3867a56a3623555720d2905bbfe8";

     

       533
       533
        
           }

     

       534
       534
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/ko/thunderbird-102.0.3.tar.bz2";

     

       534
       534
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/ko/thunderbird-102.1.2.tar.bz2";

     

       535
       535
        
             locale = "ko";

     

       536
       536
        
             arch = "linux-i686";

     

       537
       537
       -
             sha256 = "183bb61c5e4ab7ee00b5da58bee26557e82c9a9ced39e276c8a5b3f5f7974c42";

     

       537
       537
       +
             sha256 = "3b75a679e817c1c4eee93e91c71ee329b0b8fc35dc4695bbeb1b6fa3f4cd71b2";

     

       538
       538
        
           }

     

       539
       539
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/lt/thunderbird-102.0.3.tar.bz2";

     

       539
       539
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/lt/thunderbird-102.1.2.tar.bz2";

     

       540
       540
        
             locale = "lt";

     

       541
       541
        
             arch = "linux-i686";

     

       542
       542
       -
             sha256 = "da9177b28632516fecdfdb0561a9af8c502872f1f79ed552d3c7f948597ff55f";

     

       542
       542
       +
             sha256 = "00c5a79529e8daf343eb0334d1e9e5a7506c2ef6b2005a715e5305a3403b4b23";

     

       543
       543
        
           }

     

       544
       544
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/lv/thunderbird-102.0.3.tar.bz2";

     

       544
       544
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/lv/thunderbird-102.1.2.tar.bz2";

     

       545
       545
        
             locale = "lv";

     

       546
       546
        
             arch = "linux-i686";

     

       547
       547
       -
             sha256 = "5a808bff2a272396c43ecb2353dde36a1ef7f2b6c871f00e94f20f787e0ff84b";

     

       547
       547
       +
             sha256 = "84fd3ae0a1acf4af8dd00edbf612bd1186130f757a6523f8f8da124eef2d47a5";

     

       548
       548
        
           }

     

       549
       549
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/ms/thunderbird-102.0.3.tar.bz2";

     

       549
       549
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/ms/thunderbird-102.1.2.tar.bz2";

     

       550
       550
        
             locale = "ms";

     

       551
       551
        
             arch = "linux-i686";

     

       552
       552
       -
             sha256 = "e6b6ab180f723936c8a8a870359ffec20347d9fc58eb1b6406b76c7fa292ca1a";

     

       552
       552
       +
             sha256 = "3ca1fe79a9f8d9ae49ad2815c74133126d4b1b6e982903a6d2d4612f8e40c2e6";

     

       553
       553
        
           }

     

       554
       554
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/nb-NO/thunderbird-102.0.3.tar.bz2";

     

       554
       554
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/nb-NO/thunderbird-102.1.2.tar.bz2";

     

       555
       555
        
             locale = "nb-NO";

     

       556
       556
        
             arch = "linux-i686";

     

       557
       557
       -
             sha256 = "bf21182e27be5dd930b2cb2dcd31ed0c1c4c14b0c09a34e1be7f62b6aef85800";

     

       557
       557
       +
             sha256 = "1f26868424c8ee51d45254b8fd6e9695de1223d2574e7e4de2037b2f4c34af62";

     

       558
       558
        
           }

     

       559
       559
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/nl/thunderbird-102.0.3.tar.bz2";

     

       559
       559
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/nl/thunderbird-102.1.2.tar.bz2";

     

       560
       560
        
             locale = "nl";

     

       561
       561
        
             arch = "linux-i686";

     

       562
       562
       -
             sha256 = "431ac204db5cce7c76e5221df0754dbbca2c4eaaf131b7a144b2e325f2df8e5c";

     

       562
       562
       +
             sha256 = "953cf766dcc14ca591ae5633f8dfa07abe757e0dfdd5dc3ba8e2caba506b6cf8";

     

       563
       563
        
           }

     

       564
       564
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/nn-NO/thunderbird-102.0.3.tar.bz2";

     

       564
       564
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/nn-NO/thunderbird-102.1.2.tar.bz2";

     

       565
       565
        
             locale = "nn-NO";

     

       566
       566
        
             arch = "linux-i686";

     

       567
       567
       -
             sha256 = "52b6f7f08ee856f631376e78ecb0ab52ac3b88faee03f4604459b5ac8a98e18b";

     

       567
       567
       +
             sha256 = "1098dbaf39d678db1a8267f23f4e3dcffcf56cf29a3626db54d2d99f4323a14b";

     

       568
       568
        
           }

     

       569
       569
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/pa-IN/thunderbird-102.0.3.tar.bz2";

     

       569
       569
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/pa-IN/thunderbird-102.1.2.tar.bz2";

     

       570
       570
        
             locale = "pa-IN";

     

       571
       571
        
             arch = "linux-i686";

     

       572
       572
       -
             sha256 = "b1e5cbd3ac22af04a17920831d79c953311a9e1163cc4ca6e8aecaca89411152";

     

       572
       572
       +
             sha256 = "8932202b4c411b5be0cfd13cab442998ca1799d2912ac65c5ba758bc5fab3b77";

     

       573
       573
        
           }

     

       574
       574
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/pl/thunderbird-102.0.3.tar.bz2";

     

       574
       574
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/pl/thunderbird-102.1.2.tar.bz2";

     

       575
       575
        
             locale = "pl";

     

       576
       576
        
             arch = "linux-i686";

     

       577
       577
       -
             sha256 = "0a15a79b2be773aab7e9b719ce0212168479e78ceb4771096f3fbad13ee202af";

     

       577
       577
       +
             sha256 = "9bcacb8f37e8470f0550c11fab8b4a45ae3086856ba7fcb64a4065f9d3af3a84";

     

       578
       578
        
           }

     

       579
       579
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/pt-BR/thunderbird-102.0.3.tar.bz2";

     

       579
       579
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/pt-BR/thunderbird-102.1.2.tar.bz2";

     

       580
       580
        
             locale = "pt-BR";

     

       581
       581
        
             arch = "linux-i686";

     

       582
       582
       -
             sha256 = "ec994c42a39304861c0d5994826aa7baa2e5e07359fc192059a5f4a7e75232a0";

     

       582
       582
       +
             sha256 = "7d2614cd3210ff0d352143105c08ffe4d5f3763a22683ab0710fa836fa1a12ca";

     

       583
       583
        
           }

     

       584
       584
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/pt-PT/thunderbird-102.0.3.tar.bz2";

     

       584
       584
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/pt-PT/thunderbird-102.1.2.tar.bz2";

     

       585
       585
        
             locale = "pt-PT";

     

       586
       586
        
             arch = "linux-i686";

     

       587
       587
       -
             sha256 = "efc3b02b4f1ad379568aab7bcda964ace0ca6b041197522ab5beaed2f349f16d";

     

       587
       587
       +
             sha256 = "39f0165269f56e70d61b07d993b1d9ea06cfc08275fbee1d44a95b809cd8e701";

     

       588
       588
        
           }

     

       589
       589
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/rm/thunderbird-102.0.3.tar.bz2";

     

       589
       589
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/rm/thunderbird-102.1.2.tar.bz2";

     

       590
       590
        
             locale = "rm";

     

       591
       591
        
             arch = "linux-i686";

     

       592
       592
       -
             sha256 = "68e891c973d3f1c0d3e375bda27c4b3f1d778996dcad1377601cff5a93aef613";

     

       592
       592
       +
             sha256 = "649efb2f33afa27db7a9b330b903b7804b640bb5bd63133590354b832439c83b";

     

       593
       593
        
           }

     

       594
       594
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/ro/thunderbird-102.0.3.tar.bz2";

     

       594
       594
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/ro/thunderbird-102.1.2.tar.bz2";

     

       595
       595
        
             locale = "ro";

     

       596
       596
        
             arch = "linux-i686";

     

       597
       597
       -
             sha256 = "7d60e055c73d0b121e5e772447f6eb7ec7b2858ef99f2a60d5b30a6ee593d04c";

     

       597
       597
       +
             sha256 = "2634b9c82e303be352fda72c386517216da92a6e39928221c681f80afee11c5a";

     

       598
       598
        
           }

     

       599
       599
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/ru/thunderbird-102.0.3.tar.bz2";

     

       599
       599
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/ru/thunderbird-102.1.2.tar.bz2";

     

       600
       600
        
             locale = "ru";

     

       601
       601
        
             arch = "linux-i686";

     

       602
       602
       -
             sha256 = "8df485fdf589942e5e0110401fde31dc33af56fb0b1e0f972990cd25460651dc";

     

       602
       602
       +
             sha256 = "3f223227cca70e3142fdd2f537dbf9a7511ddc47ee821cf4e90c8238333a41b3";

     

       603
       603
        
           }

     

       604
       604
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/sk/thunderbird-102.0.3.tar.bz2";

     

       604
       604
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/sk/thunderbird-102.1.2.tar.bz2";

     

       605
       605
        
             locale = "sk";

     

       606
       606
        
             arch = "linux-i686";

     

       607
       607
       -
             sha256 = "b699730217177e392d0e51024dd86c93bd5655702e0e7ac628c1af729480fd8b";

     

       607
       607
       +
             sha256 = "63209953a283c2dd5a41d647eebfecb5b5da51bcb380cfe8c57fbb58228829be";

     

       608
       608
        
           }

     

       609
       609
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/sl/thunderbird-102.0.3.tar.bz2";

     

       609
       609
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/sl/thunderbird-102.1.2.tar.bz2";

     

       610
       610
        
             locale = "sl";

     

       611
       611
        
             arch = "linux-i686";

     

       612
       612
       -
             sha256 = "5cd62795e8c2195bff851e077ddd4ba0b6b725a562d1e4f95100f1e7cfb00d49";

     

       612
       612
       +
             sha256 = "ecfb2460e9c35f52f2dfe159791f576ad25611cfe028c492e30a3b385b998c68";

     

       613
       613
        
           }

     

       614
       614
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/sq/thunderbird-102.0.3.tar.bz2";

     

       614
       614
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/sq/thunderbird-102.1.2.tar.bz2";

     

       615
       615
        
             locale = "sq";

     

       616
       616
        
             arch = "linux-i686";

     

       617
       617
       -
             sha256 = "2cbe949408ec382b91fc056935014f800d13b7cc4fcd19e5d5699a6252698545";

     

       617
       617
       +
             sha256 = "6d087ac410aeda35b9b595904e28c5300226bef19a9a36b522504ae8ea3cd6a7";

     

       618
       618
        
           }

     

       619
       619
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/sr/thunderbird-102.0.3.tar.bz2";

     

       619
       619
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/sr/thunderbird-102.1.2.tar.bz2";

     

       620
       620
        
             locale = "sr";

     

       621
       621
        
             arch = "linux-i686";

     

       622
       622
       -
             sha256 = "264ee1a41398ff754b6b3b349b2728812bb0bf651aa39e3d1661b15e7f15ed02";

     

       622
       622
       +
             sha256 = "6bb2e8a43ab378432afc917a0d211867b9bb25965d257675e0f935a08c5381c7";

     

       623
       623
        
           }

     

       624
       624
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/sv-SE/thunderbird-102.0.3.tar.bz2";

     

       624
       624
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/sv-SE/thunderbird-102.1.2.tar.bz2";

     

       625
       625
        
             locale = "sv-SE";

     

       626
       626
        
             arch = "linux-i686";

     

       627
       627
       -
             sha256 = "05393be6b938ecb9327078305910204554ef34c413f95bf8bfc0fa846fd5e8da";

     

       627
       627
       +
             sha256 = "fcf9245e837e0c2514358410a074e19023ba7158668eef857daa67f5059e8411";

     

       628
       628
        
           }

     

       629
       629
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/th/thunderbird-102.0.3.tar.bz2";

     

       629
       629
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/th/thunderbird-102.1.2.tar.bz2";

     

       630
       630
        
             locale = "th";

     

       631
       631
        
             arch = "linux-i686";

     

       632
       632
       -
             sha256 = "9282291d0668dd7ac340dec6ec15cc2f53a08fa280823072c5aa285cab741f2d";

     

       632
       632
       +
             sha256 = "5c33365f0b774dafec6ab8d86e865ffc99144bb36b176ca4f2b0659913c76880";

     

       633
       633
        
           }

     

       634
       634
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/tr/thunderbird-102.0.3.tar.bz2";

     

       634
       634
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/tr/thunderbird-102.1.2.tar.bz2";

     

       635
       635
        
             locale = "tr";

     

       636
       636
        
             arch = "linux-i686";

     

       637
       637
       -
             sha256 = "415759235885f38a83269100df2492b48be42095e855841d31cd1b4b0875c280";

     

       637
       637
       +
             sha256 = "7071b53d00d2c16140c3de4867ddc0f58f27ceb8bb68f7d6c3f942a4e072db45";

     

       638
       638
        
           }

     

       639
       639
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/uk/thunderbird-102.0.3.tar.bz2";

     

       639
       639
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/uk/thunderbird-102.1.2.tar.bz2";

     

       640
       640
        
             locale = "uk";

     

       641
       641
        
             arch = "linux-i686";

     

       642
       642
       -
             sha256 = "480923d1f68028250ca5b7170c5391fe39152c4597ed307f1e232a2f6efaf1dc";

     

       642
       642
       +
             sha256 = "dc85e271eafa9bb26d266c3c6019177b68444b4705757c961895f130e222ddb3";

     

       643
       643
        
           }

     

       644
       644
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/uz/thunderbird-102.0.3.tar.bz2";

     

       644
       644
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/uz/thunderbird-102.1.2.tar.bz2";

     

       645
       645
        
             locale = "uz";

     

       646
       646
        
             arch = "linux-i686";

     

       647
       647
       -
             sha256 = "fdb1d65960820ebe14e6a8698abd11583652cd74f3f9412e2ff5c38df0a5b212";

     

       647
       647
       +
             sha256 = "a1ffa39b4a480560949ca42efed831f87c03e63b6532193f288298277efd6b46";

     

       648
       648
        
           }

     

       649
       649
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/vi/thunderbird-102.0.3.tar.bz2";

     

       649
       649
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/vi/thunderbird-102.1.2.tar.bz2";

     

       650
       650
        
             locale = "vi";

     

       651
       651
        
             arch = "linux-i686";

     

       652
       652
       -
             sha256 = "eb2bab16ff71881bbc6590ddd731ecbf9a1a19d5f499c9d023626da42e4ff3c6";

     

       652
       652
       +
             sha256 = "10414a1ad61baf1da9319826e8deb20ba79644ffb4e8de5d038d931f54b23f7a";

     

       653
       653
        
           }

     

       654
       654
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/zh-CN/thunderbird-102.0.3.tar.bz2";

     

       654
       654
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/zh-CN/thunderbird-102.1.2.tar.bz2";

     

       655
       655
        
             locale = "zh-CN";

     

       656
       656
        
             arch = "linux-i686";

     

       657
       657
       -
             sha256 = "0047b3f174dcd19556bf1f6f1f4bfa5fc87a6cab53d7e4d111ad7f321ffec09c";

     

       657
       657
       +
             sha256 = "379f4b36b6ceb7b357e8d140c062b9855cd3471573e867e4173947bf087df948";

     

       658
       658
        
           }

     

       659
       659
       -
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.0.3/linux-i686/zh-TW/thunderbird-102.0.3.tar.bz2";

     

       659
       659
       +
           { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.1.2/linux-i686/zh-TW/thunderbird-102.1.2.tar.bz2";

     

       660
       660
        
             locale = "zh-TW";

     

       661
       661
        
             arch = "linux-i686";

     

       662
       662
       -
             sha256 = "cdee1981e868cb8df03681051c02ecf07936d1f5dcdee1c0f30d6c4742042b64";

     

       662
       662
       +
             sha256 = "edd3c26c9e5e76d388c1a4f2b20f23902d81c530fdfc2b183a0714bee53a6921";

     

       663
       663
        
           }

     

       664
       664
        
           ];

     

       665
       665
        
       }

+2 -2

pkgs/applications/networking/mailreaders/thunderbird/packages.nix

···

       39
       39
        
         };

     

       40
       40
        
         thunderbird-102 = (buildMozillaMach rec {

     

       41
       41
        
           pname = "thunderbird";

     

       42
       42
       -
           version = "102.0.3";

     

       42
       42
       +
           version = "102.1.2";

     

       43
       43
        
           application = "comm/mail";

     

       44
       44
        
           applicationName = "Mozilla Thunderbird";

     

       45
       45
        
           binaryName = pname;

     

       46
       46
        
           src = fetchurl {

     

       47
       47
        
             url = "mirror://mozilla/thunderbird/releases/${version}/source/thunderbird-${version}.source.tar.xz";

     

       48
       48
       -
             sha512 = "ac9f22935ef558890c95cf7fbbbe32a5bb1b7140acb10088ed0d037d1ca5c6e11695c131eb40844807003b77e83b1dd2d9008df420ec394fed5008d5c4c6c3cb";

     

       48
       48
       +
             sha512 = "f5c6c77e932b30b43eaa6384b1dd1ab511d0ae8262cb51a5789f7c633235d5f8f343000d1cc1cae12e00a1d73571a814f98b0bf78681e00d7a51a34cfefdfdf1";

     

       49
       49
        
           };

     

       50
       50
        
           extraPatches = [

     

       51
       51
        
             # The file to be patched is different from firefox's `no-buildconfig-ffx90.patch`.

+2 -1

pkgs/applications/networking/nextcloud-client/default.nix

···

       79
       79
        
           "--prefix LD_LIBRARY_PATH : ${lib.makeLibraryPath [ libsecret ]}"

     

       80
       80
        
           # See also: https://bugreports.qt.io/browse/QTBUG-85967

     

       81
       81
        
           "--set QML_DISABLE_DISK_CACHE 1"

     

       82
       82
       -
           "--prefix PATH : ${lib.makeBinPath [ xdg-utils ]}"

     

       82
       82
       +
           # make xdg-open overrideable at runtime

     

       83
       83
       +
           "--suffix PATH : ${lib.makeBinPath [ xdg-utils ]}"

     

       83
       84
        
         ];

     

       84
       85
        
       

     

       85
       86
        
         cmakeFlags = [

+1 -1

pkgs/applications/office/jabref/default.nix

···

       119
       119
        
           unzip $out/lib/javafx-web-18-linux${lib.optionalString stdenv.isAarch64 "-aarch64"}.jar libjfxwebkit.so -d $out/lib/

     

       120
       120
        
       

     

       121
       121
        
           wrapProgram $out/bin/JabRef \

     

       122
       122
       -
             --prefix PATH : ${lib.makeBinPath [ xdg-utils ]} \

     

       122
       122
       +
             --suffix PATH : ${lib.makeBinPath [ xdg-utils ]} \

     

       123
       123
        
             --set JAVA_HOME "${jdk}" \

     

       124
       124
        
             --set JAVA_OPTS "-Djava.library.path=$out/lib/ --patch-module org.jabref=$out/share/java/jabref/resources/main"

     

       125
       125

+2 -1

pkgs/applications/office/mytetra/default.nix

···

       26
       26
        
         '';

     

       27
       27
        
       

     

       28
       28
        
         postFixup = ''

     

       29
       29
       +
           # make xdg-open overrideable at runtime

     

       29
       30
        
           wrapProgram $out/bin/mytetra \

     

       30
       30
       -
             --prefix PATH : ${xdg-utils}/bin

     

       31
       31
       +
             --suffix PATH : ${xdg-utils}/bin

     

       31
       32
        
         '';

     

       32
       33
        
       

     

       33
       34
        
         meta = with lib; {

+2 -1

pkgs/applications/version-management/git-and-tools/git-open/default.nix

···

       26
       26
        
           cp git-open $out/bin

     

       27
       27
        
           installManPage git-open.1

     

       28
       28
        
           wrapProgram $out/bin/git-open \

     

       29
       29
       -
             --prefix PATH : "${lib.makeBinPath [ git xdg-utils gnugrep ]}"

     

       29
       29
       +
             --prefix PATH : "${lib.makeBinPath [ git gnugrep ]}" \

     

       30
       30
       +
             --suffix PATH : "${lib.makeBinPath [ xdg-utils ]}"

     

       30
       31
        
         '';

     

       31
       32
        
       

     

       32
       33
        
         meta = with lib; {

+4 -1

pkgs/applications/version-management/git-and-tools/lab/default.nix

···

       22
       22
        
         ldflags = [ "-s" "-w" "-X main.version=${version}" ];

     

       23
       23
        
       

     

       24
       24
        
         postInstall = ''

     

       25
       25
       -
           wrapProgram $out/bin/lab --prefix PATH ":" "${lib.makeBinPath [ git xdg-utils ]}";

     

       25
       25
       +
           # make xdg-open overrideable at runtime

     

       26
       26
       +
           wrapProgram $out/bin/lab \

     

       27
       27
       +
             --prefix PATH ":" "${lib.makeBinPath [ git ]}" \

     

       28
       28
       +
             --suffix PATH ":" "${lib.makeBinPath [ xdg-utils ]}"

     

       26
       29
        
           installShellCompletion --cmd lab \

     

       27
       30
        
             --bash <($out/bin/lab completion bash) \

     

       28
       31
        
             --fish <($out/bin/lab completion fish) \

+3 -1

pkgs/applications/video/pipe-viewer/default.nix

···

       72
       72
        
           wrapProgram "$out/bin/pipe-viewer" \

     

       73
       73
        
             --prefix PATH : "${lib.makeBinPath [ ffmpeg wget youtube-dl yt-dlp ]}"

     

       74
       74
        
         '' + lib.optionalString withGtk3 ''

     

       75
       75
       +
           # make xdg-open overrideable at runtime

     

       75
       76
        
           wrapProgram "$out/bin/gtk-pipe-viewer" ''${gappsWrapperArgs[@]} \

     

       76
       76
       -
             --prefix PATH : "${lib.makeBinPath [ ffmpeg wget xdg-utils youtube-dl yt-dlp ]}"

     

       77
       77
       +
             --prefix PATH : "${lib.makeBinPath [ ffmpeg wget youtube-dl yt-dlp ]}" \

     

       78
       78
       +
             --suffix PATH : "${lib.makeBinPath [ xdg-utils ]}"

     

       77
       79
        
         '';

     

       78
       80
        
       

     

       79
       81
        
         meta = with lib; {

+2 -2

pkgs/development/libraries/cgreen/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "cgreen";

     

       5
       5
       -
         version = "1.4.1";

     

       5
       5
       +
         version = "1.6.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "cgreen-devs";

     

       9
       9
        
           repo = "cgreen";

     

       10
       10
        
           rev = version;

     

       11
       11
       -
           sha256 = "sha256-aQrfsiPuNrEMscZrOoONiN665KlNmnOiYj9ZIyzW304=";

     

       11
       11
       +
           sha256 = "sha256-BXch/V73a35Y6MqUlmR8mDp3ttwEAQTnqDC+ygLbIPY=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         postPatch = ''

+14 -1

pkgs/development/libraries/json-glib/default.nix

···

       4
       4
        
       , glib

     

       5
       5
        
       , meson

     

       6
       6
        
       , ninja

     

       7
       7
       +
       , nixosTests

     

       7
       8
        
       , pkg-config

     

       8
       9
        
       , gettext

     

       9
       10
        
       , gobject-introspection

     
···

       17
       18
        
         pname = "json-glib";

     

       18
       19
        
         version = "1.6.6";

     

       19
       20
        
       

     

       20
       20
       -
         outputs = [ "out" "dev" "devdoc" ];

     

       21
       21
       +
         outputs = [ "out" "dev" "devdoc" "installedTests" ];

     

       21
       22
        
       

     

       22
       23
        
         src = fetchurl {

     

       23
       24
        
           url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";

     

       24
       25
        
           sha256 = "luyYvnqR9t3jNjZyDj2i/27LuQ52zKpJSX8xpoVaSQ4=";

     

       25
       26
        
         };

     

       27
       27
       +
       

     

       28
       28
       +
         patches = [

     

       29
       29
       +
           # Add option for changing installation path of installed tests.

     

       30
       30
       +
           ./meson-add-installed-tests-prefix-option.patch

     

       31
       31
       +
         ];

     

       26
       32
        
       

     

       27
       33
        
         strictDeps = true;

     

       28
       34
        
       

     
···

       49
       55
        
           glib

     

       50
       56
        
         ];

     

       51
       57
        
       

     

       58
       58
       +
         mesonFlags = [

     

       59
       59
       +
           "-Dinstalled_test_prefix=${placeholder "installedTests"}"

     

       60
       60
       +
         ];

     

       52
       61
        
       

     

       53
       62
        
         # Run-time dependency gi-docgen found: NO (tried pkgconfig and cmake)

     

       54
       63
        
         # it should be a build-time dep for build

     
···

       73
       82
        
         '';

     

       74
       83
        
       

     

       75
       84
        
         passthru = {

     

       85
       85
       +
           tests = {

     

       86
       86
       +
             installedTests = nixosTests.installed-tests.json-glib;

     

       87
       87
       +
           };

     

       88
       88
       +
       

     

       76
       89
        
           updateScript = gnome.updateScript {

     

       77
       90
        
             packageName = pname;

     

       78
       91
        
             versionPolicy = "odd-unstable";

+27

pkgs/development/libraries/json-glib/meson-add-installed-tests-prefix-option.patch

···

       1
       1
       +
       diff --git a/json-glib/tests/meson.build b/json-glib/tests/meson.build

     

       2
       2
       +
       index 1eb56c8..dca444e 100644

     

       3
       3
       +
       --- a/json-glib/tests/meson.build

     

       4
       4
       +
       +++ b/json-glib/tests/meson.build

     

       5
       5
       +
       @@ -21,8 +21,9 @@ test_data = [

     

       6
       6
       +
          'stream-load.json',

     

       7
       7
       +
        ]

     

       8
       8
       +
        

     

       9
       9
       +
       -installed_test_bindir = join_paths(json_libexecdir, 'installed-tests', json_api_name)

     

       10
       10
       +
       -installed_test_datadir = join_paths(json_datadir, 'installed-tests', json_api_name)

     

       11
       11
       +
       +installed_test_prefix = get_option('installed_test_prefix')

     

       12
       12
       +
       +installed_test_bindir = join_paths(installed_test_prefix, 'libexec', 'installed-tests', json_api_name)

     

       13
       13
       +
       +installed_test_datadir = join_paths(installed_test_prefix, 'share', 'installed-tests', json_api_name)

     

       14
       14
       +
        

     

       15
       15
       +
        install_data(test_data, install_dir: installed_test_bindir)

     

       16
       16
       +
        

     

       17
       17
       +
       diff --git a/meson_options.txt b/meson_options.txt

     

       18
       18
       +
       index 068a03f..03f398a 100644

     

       19
       19
       +
       --- a/meson_options.txt

     

       20
       20
       +
       +++ b/meson_options.txt

     

       21
       21
       +
       @@ -10,3 +10,6 @@ option('man',

     

       22
       22
       +
        option('tests',

     

       23
       23
       +
               type: 'boolean', value: true,

     

       24
       24
       +
               description: 'Build the tests')

     

       25
       25
       +
       +option('installed_test_prefix',

     

       26
       26
       +
       +       description: 'Prefix for installed tests',

     

       27
       27
       +
       +       type: 'string')

+2 -2

pkgs/development/python-modules/fastapi-mail/default.nix

···

       19
       19
        
       

     

       20
       20
        
       buildPythonPackage rec {

     

       21
       21
        
         pname = "fastapi-mail";

     

       22
       22
       -
         version = "1.0.9";

     

       22
       22
       +
         version = "1.1.4";

     

       23
       23
        
         format = "pyproject";

     

       24
       24
        
       

     

       25
       25
        
         disabled = pythonOlder "3.7";

     
···

       28
       28
        
           owner = "sabuhish";

     

       29
       29
        
           repo = pname;

     

       30
       30
        
           rev = "refs/tags/${version}";

     

       31
       31
       -
           hash = "sha256-2Nb+FzmhsKvauT/yOCLHCEld8r+6niu9kV6EmjhC6S0=";

     

       31
       31
       +
           hash = "sha256-eQVDPkoRWlzCLwsOh+ksYniRyg02fhda6ys5QMqeLM0=";

     

       32
       32
        
         };

     

       33
       33
        
       

     

       34
       34
        
         postPatch = ''

+16 -4

pkgs/development/python-modules/pep8-naming/default.nix

···

       1
       1
        
       { lib

     

       2
       2
       -
       , fetchPypi

     

       3
       2
        
       , buildPythonPackage

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       , fetchpatch

     

       4
       5
        
       , flake8

     

       5
       6
        
       , python

     

       6
       7
        
       }:

     
···

       9
       10
        
         pname = "pep8-naming";

     

       10
       11
        
         version = "0.13.1";

     

       11
       12
        
       

     

       12
       12
       -
         src = fetchPypi {

     

       13
       13
       -
           inherit pname version;

     

       14
       14
       -
           sha256 = "sha256-Ovd82qnHll98haVs1Xk1RVPJu9P98weKd28S21TdaUQ=";

     

       13
       13
       +
         src = fetchFromGitHub {

     

       14
       14
       +
           owner = "PyCQA";

     

       15
       15
       +
           repo = pname;

     

       16
       16
       +
           rev = version;

     

       17
       17
       +
           sha256 = "sha256-NG4hLZcOMKprUyMnzkHRmUCFGyYgvT6ydBQNpgWE9h0=";

     

       15
       18
        
         };

     

       19
       19
       +
       

     

       20
       20
       +
         patches = [

     

       21
       21
       +
           # Fixes tests for flake8 => 5

     

       22
       22
       +
           # Remove on next release

     

       23
       23
       +
           (fetchpatch {

     

       24
       24
       +
             url = "https://github.com/PyCQA/pep8-naming/commit/c8808a0907f64b5d081cff8d3f9443e5ced1474e.patch";

     

       25
       25
       +
             sha256 = "sha256-4c+a0viS0rXuxj+TuIfgrKZjnrjiJjDoYBbNp3+6Ed0=";

     

       26
       26
       +
           })

     

       27
       27
       +
         ];

     

       16
       28
        
       

     

       17
       29
        
         propagatedBuildInputs = [

     

       18
       30
        
           flake8

+2 -2

pkgs/development/python-modules/pyviz-comms/default.nix

···

       7
       7
        
       

     

       8
       8
        
       buildPythonPackage rec {

     

       9
       9
        
         pname = "pyviz_comms";

     

       10
       10
       -
         version = "2.2.0";

     

       10
       10
       +
         version = "2.2.1";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchPypi {

     

       13
       13
        
           inherit pname version;

     

       14
       14
       -
           sha256 = "sha256-uMncveAfOEeEP7TQTDs/TeeEkgxx5Eztnfu1YPbJIhg=";

     

       14
       14
       +
           sha256 = "sha256-omFFuM5D0tk0s8aCbXe5E84QXFKOsuSUyJCz41Jd3zM=";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
        
         propagatedBuildInputs = [ param ];

+2 -2

pkgs/development/python-modules/sentinel/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildPythonPackage rec {

     

       4
       4
        
         pname = "sentinel";

     

       5
       5
       -
         version = "0.3.0";

     

       5
       5
       +
         version = "1.0.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchPypi {

     

       8
       8
        
           inherit pname version;

     

       9
       9
       -
           sha256 = "f28143aa4716dbc8f6193f5682176a3c33cd26aaae05d9ecf66c186a9887cc2d";

     

       9
       9
       +
           sha256 = "sha256-GQko+ZUa9ulKH4Tu/K7XkcKAl90VK4jpiJBr4wBFH9I=";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         meta = with lib; {

+5

pkgs/development/python-modules/uamqp/default.nix

···

       9
       9
        
       , fetchpatch

     

       10
       10
        
       , fetchPypi

     

       11
       11
        
       , isPy3k

     

       12
       12
       +
       , libcxxabi

     

       12
       13
        
       , openssl

     

       13
       14
        
       , Security

     

       14
       15
        
       , six

     
···

       56
       57
        
           six

     

       57
       58
        
         ] ++ lib.optionals (!isPy3k) [

     

       58
       59
        
           enum34

     

       60
       60
       +
         ];

     

       61
       61
       +
       

     

       62
       62
       +
         LDFLAGS = lib.optionals stdenv.isDarwin [

     

       63
       63
       +
           "-L${lib.getLib libcxxabi}/lib"

     

       59
       64
        
         ];

     

       60
       65
        
       

     

       61
       66
        
         dontUseCmakeConfigure = true;

+2 -2

pkgs/development/tools/analysis/pmd/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "pmd";

     

       5
       5
       -
         version = "6.47.0";

     

       5
       5
       +
         version = "6.48.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "https://github.com/pmd/pmd/releases/download/pmd_releases/${version}/pmd-bin-${version}.zip";

     

       9
       9
       -
           hash = "sha256-0rOV6l5VCdBkk5+F/k2vYtHQWzwugvp3ogaTRuXUKXE=";

     

       9
       9
       +
           hash = "sha256-DXoiV5AunDGagfq8BWHFcgGBv9OdGij5DDuxOKJYnE4=";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         nativeBuildInputs = [ unzip makeWrapper ];

+3 -3

pkgs/development/tools/analysis/tfsec/default.nix

···

       5
       5
        
       

     

       6
       6
        
       buildGoModule rec {

     

       7
       7
        
         pname = "tfsec";

     

       8
       8
       -
         version = "1.27.1";

     

       8
       8
       +
         version = "1.27.2";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchFromGitHub {

     

       11
       11
        
           owner = "aquasecurity";

     

       12
       12
        
           repo = pname;

     

       13
       13
        
           rev = "v${version}";

     

       14
       14
       -
           hash = "sha256-9RMSSgpYAmQgIAy4pJRk3tKwx+unaFmSNgXdKK3HYTU=";

     

       14
       14
       +
           hash = "sha256-SFh8LHHEdyjPmQDWcDIH/zfGvJanHcuOfVAjTFBwnoY=";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
        
         ldflags = [

     
···

       22
       22
        
           # "-extldflags '-fno-PIC -static'"

     

       23
       23
        
         ];

     

       24
       24
        
       

     

       25
       25
       -
         vendorSha256 = "sha256-o3TGEsYtd7RVGcw7guhqpbKMFkiRBpvCFUeIhnKKIeQ=";

     

       25
       25
       +
         vendorSha256 = "sha256-Z1UIE2sqIoF74uSy6sIUubpvdWdDa04gZB5gDOYJzHk=";

     

       26
       26
        
       

     

       27
       27
        
         subPackages = [

     

       28
       28
        
           "cmd/tfsec"

+21 -4

pkgs/development/tools/build-managers/gnumake/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchurl, guileSupport ? false, pkg-config, guile }:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , guileSupport ? false, guile

     

       5
       5
       +
       # avoid guile depend on bootstrap to prevent dependency cycles

     

       6
       6
       +
       , inBootstrap ? false

     

       7
       7
       +
       , pkg-config

     

       8
       8
       +
       , gnumake

     

       9
       9
       +
       }:

     

       10
       10
       +
       

     

       11
       11
       +
       let

     

       12
       12
       +
         guileEnabled = guileSupport && !inBootstrap;

     

       13
       13
       +
       in

     

       2
       14
        
       

     

       3
       15
        
       stdenv.mkDerivation rec {

     

       4
       16
        
         pname = "gnumake";

     
···

       19
       31
        
           ./0002-remove-impure-dirs.patch

     

       20
       32
        
         ];

     

       21
       33
        
       

     

       22
       22
       -
         nativeBuildInputs = lib.optionals guileSupport [ pkg-config ];

     

       23
       23
       -
         buildInputs = lib.optionals guileSupport [ guile ];

     

       34
       34
       +
         nativeBuildInputs = lib.optionals guileEnabled [ pkg-config ];

     

       35
       35
       +
         buildInputs = lib.optionals guileEnabled [ guile ];

     

       24
       36
        
       

     

       25
       25
       -
         configureFlags = lib.optional guileSupport "--with-guile"

     

       37
       37
       +
         configureFlags = lib.optional guileEnabled "--with-guile"

     

       26
       38
        
       

     

       27
       39
        
           # Make uses this test to decide whether it should keep track of

     

       28
       40
        
           # subseconds. Apple made this possible with APFS and macOS 10.13.

     
···

       35
       47
        
       

     

       36
       48
        
         outputs = [ "out" "man" "info" ];

     

       37
       49
        
         separateDebugInfo = true;

     

       50
       50
       +
       

     

       51
       51
       +
         passthru.tests = {

     

       52
       52
       +
           # make sure that the override doesn't break bootstrapping

     

       53
       53
       +
           gnumakeWithGuile = gnumake.override { guileSupport = true; };

     

       54
       54
       +
         };

     

       38
       55
        
       

     

       39
       56
        
         meta = with lib; {

     

       40
       57
        
           description = "A tool to control the generation of non-source files from sources";

+8 -3

pkgs/development/tools/godot/default.nix

···

       16
       16
        
       , freetype

     

       17
       17
        
       , openssl

     

       18
       18
        
       , alsa-lib

     

       19
       19
       +
       , alsa-plugins

     

       20
       20
       +
       , makeWrapper

     

       19
       21
        
       , libGLU

     

       20
       22
        
       , zlib

     

       21
       23
        
       , yasm

     
···

       31
       33
        
       in

     

       32
       34
        
       stdenv.mkDerivation rec {

     

       33
       35
        
         pname = "godot";

     

       34
       34
       -
         version = "3.4.4";

     

       36
       36
       +
         version = "3.5";

     

       35
       37
        
       

     

       36
       38
        
         src = fetchFromGitHub {

     

       37
       39
        
           owner = "godotengine";

     

       38
       40
        
           repo = "godot";

     

       39
       41
        
           rev = "${version}-stable";

     

       40
       40
       -
           sha256 = "sha256-3AESLzqozi7Fc80u8Ml3ergZMkIhHy4tNlRe/3FsE6k=";

     

       42
       42
       +
           sha256 = "sha256-aU5cTiz7OaM0fsv0EzJDUA1Es+Ei63CKLE6GVspJexc=";

     

       41
       43
        
         };

     

       42
       44
        
       

     

       43
       43
       -
         nativeBuildInputs = [ pkg-config ];

     

       45
       45
       +
         nativeBuildInputs = [ pkg-config makeWrapper ];

     

       44
       46
        
         buildInputs = [

     

       45
       47
        
           scons

     

       46
       48
        
           udev

     
···

       91
       93
        
           cp icon.png "$out/share/icons/godot.png"

     

       92
       94
        
           substituteInPlace "$out/share/applications/org.godotengine.Godot.desktop" \

     

       93
       95
        
             --replace "Exec=godot" "Exec=$out/bin/godot"

     

       96
       96
       +
       

     

       97
       97
       +
           makeWrapper $out/bin/godot $out/bin/godot \

     

       98
       98
       +
             --set ALSA_PLUGIN_DIR ${alsa-plugins}/lib/alsa-lib

     

       94
       99
        
         '';

     

       95
       100
        
       

     

       96
       101
        
         meta = with lib; {

+13 -12

pkgs/development/tools/godot/pkg_config_additions.patch

···

       1
       1
        
       diff --git a/platform/x11/detect.py b/platform/x11/detect.py

     

       2
       2
       -
       index 91652aad55..d12389f9f2 100644

     

       2
       2
       +
       index 98c9ddb..0cc2bff 100644

     

       3
       3
        
       --- a/platform/x11/detect.py

     

       4
       4
        
       +++ b/platform/x11/detect.py

     

       5
       5
       -
       @@ -218,6 +218,11 @@ def configure(env):

     

       5
       5
       +
       @@ -255,6 +255,10 @@ def configure(env):

     

       6
       6
        
            env.ParseConfig("pkg-config xrender --cflags --libs")

     

       7
       7
        
            env.ParseConfig("pkg-config xi --cflags --libs")

     

       8
       8
       -
       

     

       9
       9
       -
       +    env.ParseConfig("pkg-config xext --cflags --libs")

     

       8
       8
       +
        

     

       10
       9
        
       +    env.ParseConfig("pkg-config xfixes --cflags --libs")

     

       11
       10
        
       +    env.ParseConfig("pkg-config glu --cflags --libs")

     

       12
       11
        
       +    env.ParseConfig("pkg-config zlib --cflags --libs")

     

       13
       12
        
       +

     

       14
       13
        
            if env["touch"]:

     

       15
       14
        
                env.Append(CPPDEFINES=["TOUCH_ENABLED"])

     

       16
       16
       -
       

     

       17
       17
       -
       @@ -323,6 +328,7 @@ def configure(env):

     

       18
       18
       -
                print("Enabling ALSA")

     

       15
       15
       +
        

     

       16
       16
       +
       @@ -359,7 +363,7 @@ def configure(env):

     

       17
       17
       +
            if os.system("pkg-config --exists alsa") == 0:  # 0 means found

     

       19
       18
        
                env["alsa"] = True

     

       20
       19
        
                env.Append(CPPDEFINES=["ALSA_ENABLED", "ALSAMIDI_ENABLED"])

     

       20
       20
       +
       -        env.ParseConfig("pkg-config alsa --cflags")  # Only cflags, we dlopen the library.

     

       21
       21
        
       +        env.ParseConfig("pkg-config alsa --cflags --libs")

     

       22
       22
        
            else:

     

       23
       23
       -
                print("ALSA libraries not found, disabling driver")

     

       24
       24
       -
       

     

       25
       25
       -
       @@ -340,6 +346,7 @@ def configure(env):

     

       23
       23
       +
                print("Warning: ALSA libraries not found. Disabling the ALSA audio driver.")

     

       24
       24
       +
        

     

       25
       25
       +
       @@ -375,7 +379,7 @@ def configure(env):

     

       26
       26
       +
                if env["udev"]:

     

       26
       27
        
                    if os.system("pkg-config --exists libudev") == 0:  # 0 means found

     

       27
       27
       -
                        print("Enabling udev support")

     

       28
       28
        
                        env.Append(CPPDEFINES=["UDEV_ENABLED"])

     

       29
       29
       +
       -                env.ParseConfig("pkg-config libudev --cflags")  # Only cflags, we dlopen the library.

     

       29
       30
        
       +                env.ParseConfig("pkg-config libudev --cflags --libs")

     

       30
       31
        
                    else:

     

       31
       31
       -
                        print("libudev development libraries not found, disabling udev support")

     

       32
       32
       +
                        print("Warning: libudev development libraries not found. Disabling controller hotplugging support.")

     

       32
       33
        
            else:

+2 -1

pkgs/games/enigma/default.nix

···

       31
       31
        
       

     

       32
       32
        
         postInstall = ''

     

       33
       33
        
           rm -r $out/include

     

       34
       34
       -
           wrapProgram $out/bin/enigma --prefix PATH : "${lib.makeBinPath [ xdg-utils ]}"

     

       34
       34
       +
           # make xdg-open overrideable at runtime

     

       35
       35
       +
           wrapProgram $out/bin/enigma --suffix PATH : "${lib.makeBinPath [ xdg-utils ]}"

     

       35
       36
        
         '';

     

       36
       37
        
       

     

       37
       38
        
         meta = with lib; {

+3 -1

pkgs/games/grapejuice/default.nix

···

       56
       56
        
       

     

       57
       57
        
         makeWrapperArgs = [

     

       58
       58
        
           "\${gappsWrapperArgs[@]}"

     

       59
       59
       -
           "--prefix PATH : ${lib.makeBinPath [ xdg-user-dirs xdg-utils wine winetricks pciutils glxinfo ]}"

     

       59
       59
       +
           "--prefix PATH : ${lib.makeBinPath [ xdg-user-dirs wine winetricks pciutils glxinfo ]}"

     

       60
       60
       +
           # make xdg-open overrideable at runtime

     

       61
       61
       +
           "--suffix PATH : ${lib.makeBinPath [ xdg-utils ]}"

     

       60
       62
        
         ];

     

       61
       63
        
       

     

       62
       64
        
         postPatch = ''

+4 -4

pkgs/os-specific/linux/kernel/zen-kernels.nix

···

       4
       4
        
         # comments with variant added for update script

     

       5
       5
        
         # ./update-zen.py zen

     

       6
       6
        
         zenVariant = {

     

       7
       7
       -
           version = "5.19.1"; #zen

     

       7
       7
       +
           version = "5.19.2"; #zen

     

       8
       8
        
           suffix = "zen1"; #zen

     

       9
       9
       -
           sha256 = "1b906fa4hk56y5g1hx50kp395fakrphna4nnvy98vs8cxpcfyqi7"; #zen

     

       9
       9
       +
           sha256 = "0n21karcw9f861h26jxh29yiyg67kcxja7wh1xpdgx957avazacp"; #zen

     

       10
       10
        
           isLqx = false;

     

       11
       11
        
         };

     

       12
       12
        
         # ./update-zen.py lqx

     

       13
       13
        
         lqxVariant = {

     

       14
       14
       -
           version = "5.18.17"; #lqx

     

       14
       14
       +
           version = "5.19.2"; #lqx

     

       15
       15
        
           suffix = "lqx1"; #lqx

     

       16
       16
       -
           sha256 = "1cf4ix9xx1yi781xsrkaxn673mzi98dxlccsfvky78gjchmc8d6p"; #lqx

     

       16
       16
       +
           sha256 = "00rssb305yxv085jhy642m8iyrbz5lvi4ynkc8vqr83y9w6ilf8y"; #lqx

     

       17
       17
        
           isLqx = true;

     

       18
       18
        
         };

     

       19
       19
        
         zenKernelsFor = { version, suffix, sha256, isLqx }: buildLinux (args // {

+3 -3

pkgs/os-specific/linux/rtl8814au/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation {

     

       4
       4
        
         pname = "rtl8814au";

     

       5
       5
       -
         version = "${kernel.version}-unstable-2022-05-23";

     

       5
       5
       +
         version = "${kernel.version}-unstable-2022-08-18";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "morrownr";

     

       9
       9
        
           repo = "8814au";

     

       10
       10
       -
           rev = "687f05c73e22dc14d5f24f2bb92f2ecac3cc71d5";

     

       11
       11
       -
           sha256 = "08znnihk9rdrwgyzazxqcrzwdjnm5q8ah92bfb552wjv11r87zv1";

     

       10
       10
       +
           rev = "752d8ea365b2affc5d356e35659600995508849d";

     

       11
       11
       +
           hash = "sha256-m79IVoD3xFigmax13qELx5e3v0NfJSwmmC0PatA91HI=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         nativeBuildInputs = kernel.moduleBuildDependencies;

+3 -3

pkgs/os-specific/linux/rtl88x2bu/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "rtl88x2bu";

     

       5
       5
       -
         version = "${kernel.version}-unstable-2022-05-23";

     

       5
       5
       +
         version = "${kernel.version}-unstable-2022-08-18";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "morrownr";

     

       9
       9
        
           repo = "88x2bu-20210702";

     

       10
       10
       -
           rev = "3fbe980a9a8cee223e4671449128212cf7514b3c";

     

       11
       11
       -
           sha256 = "1p4bp8g94ny385nl3m2ca824dbm6lhjvh7s5rqyzk220il2sa0nd";

     

       10
       10
       +
           rev = "6dda660a6af1b18654bbbbedd933cdf30683b7a1";

     

       11
       11
       +
           sha256 = "sha256-o+SLc8EQA3DHYdZQToyoZS0TFkuVEnFStQQUOCFPYXI=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         hardeningDisable = [ "pic" ];

+2 -2

pkgs/servers/grocy/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "grocy";

     

       5
       5
       -
         version = "3.3.0";

     

       5
       5
       +
         version = "3.3.1";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "https://github.com/grocy/grocy/releases/download/v${version}/grocy_${version}.zip";

     

       9
       9
       -
           sha256 = "sha256-y0l0V+cTIfZYtyV8l6kdFW9UzJWb7eQMEocaPo7TLbg=";

     

       9
       9
       +
           sha256 = "sha256-XqjYDha9wwfITEDRZsnH/ig+9q1/SfKIwQYg1svUaXM=";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         nativeBuildInputs = [ unzip ];

+3 -2

pkgs/servers/teleport/default.nix

···

       119
       119
        
       

     

       120
       120
        
         postInstall = ''

     

       121
       121
        
           install -Dm755 -t $client/bin $out/bin/tsh

     

       122
       122
       -
           wrapProgram $client/bin/tsh --prefix PATH : ${lib.makeBinPath [ xdg-utils ]}

     

       123
       123
       -
           wrapProgram $out/bin/tsh --prefix PATH : ${lib.makeBinPath [ xdg-utils ]}

     

       122
       122
       +
           # make xdg-open overrideable at runtime

     

       123
       123
       +
           wrapProgram $client/bin/tsh --suffix PATH : ${lib.makeBinPath [ xdg-utils ]}

     

       124
       124
       +
           wrapProgram $out/bin/tsh --suffix PATH : ${lib.makeBinPath [ xdg-utils ]}

     

       124
       125
        
         '';

     

       125
       126
        
       

     

       126
       127
        
         doInstallCheck = true;

+6 -1

pkgs/stdenv/linux/default.nix

···

       356
       356
        
             #   stage5.gcc -> stage4.coreutils -> stage3.glibc -> bootstrap

     

       357
       357
        
             gmp = lib.makeOverridable (super.gmp.override { stdenv = self.stdenv; }).overrideAttrs (a: { pname = "${a.pname}-stage4"; });

     

       358
       358
        
       

     

       359
       359
       +
             # To allow users' overrides inhibit dependencies too heavy for

     

       360
       360
       +
             # bootstrap, like guile: https://github.com/NixOS/nixpkgs/issues/181188

     

       361
       361
       +
             gnumake = super.gnumake.override { inBootstrap = true; };

     

       362
       362
       +
       

     

       359
       363
        
             gcc = lib.makeOverridable (import ../../build-support/cc-wrapper) {

     

       360
       364
        
               nativeTools = false;

     

       361
       365
        
               nativeLibc = false;

     
···

       446
       450
        
             overrides = self: super: {

     

       447
       451
        
               inherit (prevStage)

     

       448
       452
        
                 gzip bzip2 xz bash coreutils diffutils findutils gawk

     

       449
       449
       -
                 gnumake gnused gnutar gnugrep gnupatch patchelf

     

       453
       453
       +
                 gnused gnutar gnugrep gnupatch patchelf

     

       450
       454
        
                 attr acl zlib pcre libunistring;

     

       451
       455
        
               ${localSystem.libc} = getLibc prevStage;

     

       452
       456
        
       

     
···

       457
       461
        
                 inherit (self) stdenv runCommandLocal patchelf libunistring;

     

       458
       462
        
               };

     

       459
       463
        
       

     

       464
       464
       +
               gnumake = super.gnumake.override { inBootstrap = false; };

     

       460
       465
        
             } // lib.optionalAttrs (super.stdenv.targetPlatform == localSystem) {

     

       461
       466
        
               # Need to get rid of these when cross-compiling.

     

       462
       467
        
               inherit (prevStage) binutils binutils-unwrapped;

-1

pkgs/stdenv/linux/make-bootstrap-tools.nix

···

       152
       152
        
               cp -d ${mpfr.out}/lib/libmpfr*.so* $out/lib

     

       153
       153
        
               cp -d ${libmpc.out}/lib/libmpc*.so* $out/lib

     

       154
       154
        
               cp -d ${zlib.out}/lib/libz.so* $out/lib

     

       155
       155
       -
               cp -d ${libelf}/lib/libelf.so* $out/lib

     

       156
       155
        
       

     

       157
       156
        
             '' + lib.optionalString (stdenv.hostPlatform != stdenv.buildPlatform) ''

     

       158
       157
        
               # These needed for cross but not native tools because the stdenv

+1 -1

pkgs/tools/admin/aws-sso-cli/default.nix

···

       21
       21
        
         postInstall = ''

     

       22
       22
        
           mv $out/bin/cmd $out/bin/aws-sso

     

       23
       23
        
           wrapProgram $out/bin/aws-sso \

     

       24
       24
       -
             --prefix PATH : ${lib.makeBinPath [ xdg-utils ]}

     

       24
       24
       +
             --suffix PATH : ${lib.makeBinPath [ xdg-utils ]}

     

       25
       25
        
         '';

     

       26
       26
        
       

     

       27
       27
        
         meta = with lib; {

+2 -1

pkgs/tools/admin/aws-vault/default.nix

···

       21
       21
        
         nativeBuildInputs = [ installShellFiles makeWrapper ];

     

       22
       22
        
       

     

       23
       23
        
         postInstall = ''

     

       24
       24
       -
           wrapProgram $out/bin/aws-vault --prefix PATH : ${lib.makeBinPath [ xdg-utils ]}

     

       24
       24
       +
           # make xdg-open overrideable at runtime

     

       25
       25
       +
           wrapProgram $out/bin/aws-vault --suffix PATH : ${lib.makeBinPath [ xdg-utils ]}

     

       25
       26
        
           installShellCompletion --cmd aws-vault \

     

       26
       27
        
             --bash $src/contrib/completions/bash/aws-vault.bash \

     

       27
       28
        
             --fish $src/contrib/completions/fish/aws-vault.fish \

+5 -2

pkgs/tools/bluetooth/blueman/default.nix

···

       5
       5
        
       

     

       6
       6
        
       let

     

       7
       7
        
         pythonPackages = python3Packages;

     

       8
       8
       -
         binPath = lib.makeBinPath [ xdg-utils dnsmasq dhcp iproute2 ];

     

       9
       8
        
       

     

       10
       9
        
       in stdenv.mkDerivation rec {

     

       11
       10
        
         pname = "blueman";

     
···

       41
       40
        
           (lib.enableFeature withPulseAudio "pulseaudio")

     

       42
       41
        
         ];

     

       43
       42
        
       

     

       43
       43
       +
         makeWrapperArgs = [

     

       44
       44
       +
           "--prefix PATH ':' ${lib.makeBinPath [ dnsmasq dhcp iproute2 ]}"

     

       45
       45
       +
           "--suffix PATH ':' ${lib.makeBinPath [ xdg-utils ]}"

     

       46
       46
       +
         ];

     

       47
       47
       +
       

     

       44
       48
        
         postFixup = ''

     

       45
       45
       -
           makeWrapperArgs="--prefix PATH ':' ${binPath}"

     

       46
       49
        
           # This mimics ../../../development/interpreters/python/wrap.sh

     

       47
       50
        
           wrapPythonProgramsIn "$out/bin" "$out $pythonPath"

     

       48
       51
        
           wrapPythonProgramsIn "$out/libexec" "$out $pythonPath"

+3 -3

pkgs/tools/misc/writedisk/default.nix

···

       7
       7
        
       

     

       8
       8
        
       rustPlatform.buildRustPackage rec {

     

       9
       9
        
         pname = "writedisk";

     

       10
       10
       -
         version = "1.2.0";

     

       10
       10
       +
         version = "1.3.0";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchCrate {

     

       13
       13
        
           inherit version;

     

       14
       14
        
           pname = "writedisk";

     

       15
       15
       -
           sha256 = "sha256-f5+Qw9Agepx2wIUmsAA2M9g/ajbFjjLR5RPPtQncRKU=";

     

       15
       15
       +
           sha256 = "sha256-MZFnNb8rJMu/nlH8rfnD//bhqPSkhyXucbTrwsRM9OY=";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
       -
         cargoSha256 = "sha256-SMAhh7na+XQyVtbfzsBGOCdBRLP58JL1fPSBVKFkhdc=";

     

       18
       18
       +
         cargoSha256 = "sha256-DGroBBozAViibbIYbtqH2SxIGLqdtyJ9XKyz7O1L05g=";

     

       19
       19
        
       

     

       20
       20
        
         nativeBuildInputs = [ pkg-config ];

     

       21
       21

+26

pkgs/tools/networking/ghz/default.nix

···

       1
       1
       +
       { lib, buildGoModule, fetchFromGitHub }:

     

       2
       2
       +
       

     

       3
       3
       +
       buildGoModule rec {

     

       4
       4
       +
         pname = "ghz";

     

       5
       5
       +
         version = "0.109.0";

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchFromGitHub {

     

       8
       8
       +
           owner = "bojand";

     

       9
       9
       +
           repo = "ghz";

     

       10
       10
       +
           rev = "v${version}";

     

       11
       11
       +
           sha256 = "sha256-5l2PeN+VxTaORAkmAfI9TCGd4W6y8BFs/eY4T9nYJuc=";

     

       12
       12
       +
         };

     

       13
       13
       +
       

     

       14
       14
       +
         vendorSha256 = "sha256-qZD+qxjjFgyQDtjOQcilS4w2sS9I+7iCK2/ThaAJTy4=";

     

       15
       15
       +
       

     

       16
       16
       +
         subPackages = [ "cmd/ghz" "cmd/ghz-web" ];

     

       17
       17
       +
       

     

       18
       18
       +
         ldflags = [ "-s" "-w" ];

     

       19
       19
       +
       

     

       20
       20
       +
         meta = with lib; {

     

       21
       21
       +
           description = "Simple gRPC benchmarking and load testing tool";

     

       22
       22
       +
           homepage = "https://ghz.sh";

     

       23
       23
       +
           license = licenses.asl20;

     

       24
       24
       +
           maintainers = [ maintainers.zombiezen ];

     

       25
       25
       +
         };

     

       26
       26
       +
       }

+4

pkgs/top-level/all-packages.nix

···

       6599
       6599
        
       

     

       6600
       6600
        
         ghrepo-stats = with python3Packages; toPythonApplication ghrepo-stats;

     

       6601
       6601
        
       

     

       6602
       6602
       +
         ghz = callPackage ../tools/networking/ghz { };

     

       6603
       6603
       +
       

     

       6602
       6604
        
         gibberish-detector = with python3Packages; toPythonApplication gibberish-detector;

     

       6603
       6605
        
       

     

       6604
       6606
        
         gibo = callPackage ../tools/misc/gibo { };

     
···

       26430
       26432
        
         };

     

       26431
       26433
        
       

     

       26432
       26434
        
         blender-with-packages = callPackage ../applications/misc/blender/wrapper.nix {};

     

       26435
       26435
       +
       

     

       26436
       26436
       +
         blender-hip = blender.override { hipSupport = true; };

     

       26433
       26437
        
       

     

       26434
       26438
        
         blflash = callPackage ../tools/misc/blflash { };

     

       26435
       26439