commit 6eadb16022b6e52f3cdb2167aaa7b82e221bfc1a · pyrox.dev/nixpkgs

+2 -6

nixos/modules/config/fonts/fontconfig.nix

···

       108
       108
        
               subpixel = {

     

       109
       109
        
       

     

       110
       110
        
                 rgba = mkOption {

     

       111
       111
       -
                   type = types.string // {

     

       112
       112
       -
                     check = flip elem ["rgb" "bgr" "vrgb" "vbgr" "none"];

     

       113
       113
       -
                   };

     

       114
       111
        
                   default = "rgb";

     

       112
       112
       +
                   type = types.enum ["rgb" "bgr" "vrgb" "vbgr" "none"];

     

       115
       113
        
                   description = ''

     

       116
       114
        
                     Subpixel order, one of <literal>none</literal>,

     

       117
       115
        
                     <literal>rgb</literal>, <literal>bgr</literal>,

     
···

       120
       118
        
                 };

     

       121
       119
        
       

     

       122
       120
        
                 lcdfilter = mkOption {

     

       123
       123
       -
                   type = types.str // {

     

       124
       124
       -
                     check = flip elem ["none" "default" "light" "legacy"];

     

       125
       125
       -
                   };

     

       126
       121
        
                   default = "default";

     

       122
       122
       +
                   type = types.enum ["none" "default" "light" "legacy"];

     

       127
       123
        
                   description = ''

     

       128
       124
        
                     FreeType LCD filter, one of <literal>none</literal>,

     

       129
       125
        
                     <literal>default</literal>, <literal>light</literal>, or

+5 -5

nixos/modules/config/ldap.nix

···

       108
       108
        
       

     

       109
       109
        
               extraConfig = mkOption {

     

       110
       110
        
                 default =  "";

     

       111
       111
       -
                 type = types.string;

     

       111
       111
       +
                 type = types.lines;

     

       112
       112
        
                 description = ''

     

       113
       113
        
                   Extra configuration options that will be added verbatim at

     

       114
       114
        
                   the end of the nslcd configuration file (nslcd.conf).

     
···

       120
       120
        
               distinguishedName = mkOption {

     

       121
       121
        
                 default = "";

     

       122
       122
        
                 example = "cn=admin,dc=example,dc=com";

     

       123
       123
       -
                 type = types.string;

     

       123
       123
       +
                 type = types.str;

     

       124
       124
        
                 description = ''

     

       125
       125
        
                   The distinguished name to bind to the LDAP server with. If this

     

       126
       126
        
                   is not specified, an anonymous bind will be done.

     
···

       129
       129
        
       

     

       130
       130
        
               password = mkOption {

     

       131
       131
        
                 default = "/etc/ldap/bind.password";

     

       132
       132
       -
                 type = types.string;

     

       132
       132
       +
                 type = types.str;

     

       133
       133
        
                 description = ''

     

       134
       134
        
                   The path to a file containing the credentials to use when binding

     

       135
       135
        
                   to the LDAP server (if not binding anonymously).

     
···

       149
       149
        
       

     

       150
       150
        
               policy = mkOption {

     

       151
       151
        
                 default = "hard_open";

     

       152
       152
       -
                 type = types.string;

     

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

     

       153
       153
        
                 description = ''

     

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

     

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

     
···

       168
       168
        
       

     

       169
       169
        
             extraConfig = mkOption {

     

       170
       170
        
               default = "";

     

       171
       171
       -
               type = types.string;

     

       171
       171
       +
               type = types.lines;

     

       172
       172
        
               description = ''

     

       173
       173
        
                 Extra configuration options that will be added verbatim at

     

       174
       174
        
                 the end of the ldap configuration file (ldap.conf).

+7 -7

nixos/modules/programs/venus.nix

···

       41
       41
        
       

     

       42
       42
        
             dates = mkOption {

     

       43
       43
        
               default = "*:0/15";

     

       44
       44
       -
               type = types.string;

     

       44
       44
       +
               type = types.str;

     

       45
       45
        
               description = ''

     

       46
       46
        
                 Specification (in the format described by

     

       47
       47
        
                 <citerefentry><refentrytitle>systemd.time</refentrytitle>

     
···

       52
       52
        
       

     

       53
       53
        
             user = mkOption {

     

       54
       54
        
               default = "root";

     

       55
       55
       -
               type = types.string;

     

       55
       55
       +
               type = types.str;

     

       56
       56
        
               description = ''

     

       57
       57
        
                 User for running venus script.

     

       58
       58
        
               '';

     
···

       60
       60
        
       

     

       61
       61
        
             group = mkOption {

     

       62
       62
        
               default = "root";

     

       63
       63
       -
               type = types.string;

     

       63
       63
       +
               type = types.str;

     

       64
       64
        
               description = ''

     

       65
       65
        
                 Group for running venus script.

     

       66
       66
        
               '';

     
···

       68
       68
        
       

     

       69
       69
        
             name = mkOption {

     

       70
       70
        
               default = "NixOS Planet";

     

       71
       71
       -
               type = types.string;

     

       71
       71
       +
               type = types.str;

     

       72
       72
        
               description = ''

     

       73
       73
        
                 Your planet's name.

     

       74
       74
        
               '';

     
···

       76
       76
        
       

     

       77
       77
        
             link = mkOption {

     

       78
       78
        
               default = "http://planet.nixos.org";

     

       79
       79
       -
               type = types.string;

     

       79
       79
       +
               type = types.str;

     

       80
       80
        
               description = ''

     

       81
       81
        
                 Link to the main page.

     

       82
       82
        
               '';

     
···

       84
       84
        
       

     

       85
       85
        
             ownerName = mkOption {

     

       86
       86
        
               default = "Rok Garbas";

     

       87
       87
       -
               type = types.string;

     

       87
       87
       +
               type = types.str;

     

       88
       88
        
               description = ''

     

       89
       89
        
                 Your name.

     

       90
       90
        
               '';

     
···

       92
       92
        
       

     

       93
       93
        
             ownerEmail = mkOption {

     

       94
       94
        
               default = "some@example.com";

     

       95
       95
       -
               type = types.string;

     

       95
       95
       +
               type = types.str;

     

       96
       96
        
               description = ''

     

       97
       97
        
                 Your e-mail address.

     

       98
       98
        
               '';

+2 -2

nixos/modules/programs/wvdial.nix

···

       24
       24
        
       

     

       25
       25
        
             dialerDefaults = mkOption {

     

       26
       26
        
               default = "";

     

       27
       27
       -
               type = types.string;

     

       27
       27
       +
               type = types.str;

     

       28
       28
        
               example = ''Init1 = AT+CGDCONT=1,"IP","internet.t-mobile"'';

     

       29
       29
        
               description = ''

     

       30
       30
        
                 Contents of the "Dialer Defaults" section of

     
···

       40
       40
        
                 persist

     

       41
       41
        
                 noauth

     

       42
       42
        
               '';

     

       43
       43
       -
               type = types.string;

     

       43
       43
       +
               type = types.str;

     

       44
       44
        
               description = "Default ppp settings for wvdial.";

     

       45
       45
        
             };

     

       46
       46

+4 -4

nixos/modules/programs/xfs_quota.nix

···

       32
       32
        
                   };

     

       33
       33
        
       

     

       34
       34
        
                   fileSystem = mkOption {

     

       35
       35
       -
                     type = types.string;

     

       35
       35
       +
                     type = types.str;

     

       36
       36
        
                     description = "XFS filesystem hosting the xfs_quota project.";

     

       37
       37
        
                     default = "/";

     

       38
       38
        
                   };

     

       39
       39
        
       

     

       40
       40
        
                   path = mkOption {

     

       41
       41
       -
                     type = types.string;

     

       41
       41
       +
                     type = types.str;

     

       42
       42
        
                     description = "Project directory.";

     

       43
       43
        
                   };

     

       44
       44
        
       

     

       45
       45
        
                   sizeSoftLimit = mkOption {

     

       46
       46
       -
                     type = types.nullOr types.string;

     

       46
       46
       +
                     type = types.nullOr types.str;

     

       47
       47
        
                     default = null;

     

       48
       48
        
                     example = "30g";

     

       49
       49
        
                     description = "Soft limit of the project size";

     

       50
       50
        
                   };

     

       51
       51
        
       

     

       52
       52
        
                   sizeHardLimit = mkOption {

     

       53
       53
       -
                     type = types.nullOr types.string;

     

       53
       53
       +
                     type = types.nullOr types.str;

     

       54
       54
        
                     default = null;

     

       55
       55
        
                     example = "50g";

     

       56
       56
        
                     description = "Hard limit of the project size.";

+1 -1

nixos/modules/security/pam.nix

···

       419
       419
        
           users.motd = mkOption {

     

       420
       420
        
             default = null;

     

       421
       421
        
             example = "Today is Sweetmorn, the 4th day of The Aftermath in the YOLD 3178.";

     

       422
       422
       -
             type = types.nullOr types.string;

     

       422
       422
       +
             type = types.nullOr types.lines;

     

       423
       423
        
             description = "Message of the day shown to users when they log in.";

     

       424
       424
        
           };

     

       425
       425

+2 -2

nixos/modules/security/prey.nix

···

       24
       24
        
             };

     

       25
       25
        
       

     

       26
       26
        
             deviceKey = mkOption {

     

       27
       27
       -
               type = types.string;

     

       27
       27
       +
               type = types.str;

     

       28
       28
        
               description = ''

     

       29
       29
        
                 <literal>Device key</literal> obtained by visiting

     

       30
       30
        
                 <link xlink:href="https://panel.preyproject.com/devices" />

     
···

       33
       33
        
             };

     

       34
       34
        
       

     

       35
       35
        
             apiKey = mkOption {

     

       36
       36
       -
               type = types.string;

     

       36
       36
       +
               type = types.str;

     

       37
       37
        
               description = ''

     

       38
       38
        
                 <literal>API key</literal> obtained from

     

       39
       39
        
                 <link xlink:href="https://panel.preyproject.com/profile" />.

+2 -2

nixos/modules/services/monitoring/smartd.nix

···

       119
       119
        
       

     

       120
       120
        
                 recipient = mkOption {

     

       121
       121
        
                   default = "root";

     

       122
       122
       -
                   type = types.string;

     

       122
       122
       +
                   type = types.str;

     

       123
       123
        
                   description = "Recipient of the notification messages.";

     

       124
       124
        
                 };

     

       125
       125
        
       

     
···

       153
       153
        
       

     

       154
       154
        
                 display = mkOption {

     

       155
       155
        
                   default = ":${toString config.services.xserver.display}";

     

       156
       156
       -
                   type = types.string;

     

       156
       156
       +
                   type = types.str;

     

       157
       157
        
                   description = "DISPLAY to send X11 notifications to.";

     

       158
       158
        
                 };

     

       159
       159
        
               };

+1 -1

nixos/modules/system/boot/loader/efi.nix

···

       15
       15
        
           efiSysMountPoint = mkOption {

     

       16
       16
        
             default = "/boot";

     

       17
       17
        
       

     

       18
       18
       -
             type = types.string;

     

       18
       18
       +
             type = types.str;

     

       19
       19
        
       

     

       20
       20
        
             description = "Where the EFI System Partition is mounted.";

     

       21
       21
        
           };

+8 -8

nixos/modules/system/boot/luksroot.nix

···

       242
       242
        
       

     

       243
       243
        
               name = mkOption {

     

       244
       244
        
                 example = "luksroot";

     

       245
       245
       -
                 type = types.string;

     

       245
       245
       +
                 type = types.str;

     

       246
       246
        
                 description = "Named to be used for the generated device in /dev/mapper.";

     

       247
       247
        
               };

     

       248
       248
        
       

     

       249
       249
        
               device = mkOption {

     

       250
       250
        
                 example = "/dev/sda2";

     

       251
       251
       -
                 type = types.string;

     

       251
       251
       +
                 type = types.str;

     

       252
       252
        
                 description = "Path of the underlying block device.";

     

       253
       253
        
               };

     

       254
       254
        
       

     

       255
       255
        
               header = mkOption {

     

       256
       256
        
                 default = null;

     

       257
       257
        
                 example = "/root/header.img";

     

       258
       258
       -
                 type = types.nullOr types.string;

     

       258
       258
       +
                 type = types.nullOr types.str;

     

       259
       259
        
                 description = ''

     

       260
       260
        
                   The name of the file or block device that

     

       261
       261
        
                   should be used as header for the encrypted device.

     
···

       265
       265
        
               keyFile = mkOption {

     

       266
       266
        
                 default = null;

     

       267
       267
        
                 example = "/dev/sdb1";

     

       268
       268
       -
                 type = types.nullOr types.string;

     

       268
       268
       +
                 type = types.nullOr types.str;

     

       269
       269
        
                 description = ''

     

       270
       270
        
                   The name of the file (can be a raw device or a partition) that

     

       271
       271
        
                   should be used as the decryption key for the encrypted device. If

     
···

       349
       349
        
       

     

       350
       350
        
                   ramfsMountPoint = mkOption {

     

       351
       351
        
                     default = "/crypt-ramfs";

     

       352
       352
       -
                     type = types.string;

     

       352
       352
       +
                     type = types.str;

     

       353
       353
        
                     description = "Path where the ramfs used to update the LUKS key will be mounted during early boot.";

     

       354
       354
        
                   };

     

       355
       355
        
       

     
···

       369
       369
        
       

     

       370
       370
        
                     fsType = mkOption {

     

       371
       371
        
                       default = "vfat";

     

       372
       372
       -
                       type = types.string;

     

       372
       372
       +
                       type = types.str;

     

       373
       373
        
                       description = "The filesystem of the unencrypted device.";

     

       374
       374
        
                     };

     

       375
       375
        
       

     

       376
       376
        
                     mountPoint = mkOption {

     

       377
       377
        
                       default = "/crypt-storage";

     

       378
       378
       -
                       type = types.string;

     

       378
       378
       +
                       type = types.str;

     

       379
       379
        
                       description = "Path where the unencrypted device will be mounted during early boot.";

     

       380
       380
        
                     };

     

       381
       381
        
       

     

       382
       382
        
                     path = mkOption {

     

       383
       383
        
                       default = "/crypt-storage/default";

     

       384
       384
       -
                       type = types.string;

     

       384
       384
       +
                       type = types.str;

     

       385
       385
        
                       description = ''

     

       386
       386
        
                         Absolute path of the salt on the unencrypted device with

     

       387
       387
        
                         that device's root directory as "/".

+3 -3

nixos/modules/tasks/encrypted-devices.nix

···

       22
       22
        
             blkDev = mkOption {

     

       23
       23
        
               default = null;

     

       24
       24
        
               example = "/dev/sda1";

     

       25
       25
       -
               type = types.uniq (types.nullOr types.string);

     

       25
       25
       +
               type = types.nullOr types.str;

     

       26
       26
        
               description = "Location of the backing encrypted device.";

     

       27
       27
        
             };

     

       28
       28
        
       

     

       29
       29
        
             label = mkOption {

     

       30
       30
        
               default = null;

     

       31
       31
        
               example = "rootfs";

     

       32
       32
       -
               type = types.uniq (types.nullOr types.string);

     

       32
       32
       +
               type = types.nullOr types.str;

     

       33
       33
        
               description = "Label of the backing encrypted device.";

     

       34
       34
        
             };

     

       35
       35
        
       

     

       36
       36
        
             keyFile = mkOption {

     

       37
       37
        
               default = null;

     

       38
       38
        
               example = "/root/.swapkey";

     

       39
       39
       -
               type = types.uniq (types.nullOr types.string);

     

       39
       39
       +
               type = types.nullOr types.str;

     

       40
       40
        
               description = "File system location of keyfile.";

     

       41
       41
        
             };

     

       42
       42
        
           };

+2 -2

nixos/modules/tasks/filesystems.nix

···

       22
       22
        
             device = mkOption {

     

       23
       23
        
               default = null;

     

       24
       24
        
               example = "/dev/sda";

     

       25
       25
       -
               type = types.uniq (types.nullOr types.string);

     

       25
       25
       +
               type = types.nullOr types.str;

     

       26
       26
        
               description = "Location of the device.";

     

       27
       27
        
             };

     

       28
       28
        
       

     

       29
       29
        
             label = mkOption {

     

       30
       30
        
               default = null;

     

       31
       31
        
               example = "root-partition";

     

       32
       32
       -
               type = types.uniq (types.nullOr types.string);

     

       32
       32
       +
               type = types.nullOr types.str;

     

       33
       33
        
               description = "Label of the device (if any).";

     

       34
       34
        
             };

     

       35
       35

+2 -2

nixos/modules/tasks/network-interfaces.nix

···

       499
       499
        
       

     

       500
       500
        
               interface = mkOption {

     

       501
       501
        
                 example = "enp4s0";

     

       502
       502
       -
                 type = types.string;

     

       502
       502
       +
                 type = types.str;

     

       503
       503
        
                 description = "The interface the macvlan will transmit packets through.";

     

       504
       504
        
               };

     

       505
       505
        
       

     
···

       605
       605
        
       

     

       606
       606
        
               interface = mkOption {

     

       607
       607
        
                 example = "enp4s0";

     

       608
       608
       -
                 type = types.string;

     

       608
       608
       +
                 type = types.str;

     

       609
       609
        
                 description = "The interface the vlan will transmit packets through.";

     

       610
       610
        
               };

     

       611
       611

+2 -2

nixos/modules/virtualisation/containers.nix

···

       108
       108
        
                   };

     

       109
       109
        
       

     

       110
       110
        
                   hostAddress = mkOption {

     

       111
       111
       -
                     type = types.nullOr types.string;

     

       111
       111
       +
                     type = types.nullOr types.str;

     

       112
       112
        
                     default = null;

     

       113
       113
        
                     example = "10.231.136.1";

     

       114
       114
        
                     description = ''

     
···

       117
       117
        
                   };

     

       118
       118
        
       

     

       119
       119
        
                   localAddress = mkOption {

     

       120
       120
       -
                     type = types.nullOr types.string;

     

       120
       120
       +
                     type = types.nullOr types.str;

     

       121
       121
        
                     default = null;

     

       122
       122
        
                     example = "10.231.136.2";

     

       123
       123
        
                     description = ''

+1 -1

nixos/modules/virtualisation/docker.nix

···

       67
       67
        
       

     

       68
       68
        
           postStart =

     

       69
       69
        
             mkOption {

     

       70
       70
       -
               type = types.string;

     

       70
       70
       +
               type = types.lines;

     

       71
       71
        
               default = ''

     

       72
       72
        
                 while ! [ -e /var/run/docker.sock ]; do

     

       73
       73
        
                   sleep 0.1