---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (3, 6),
  },
  target: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cfg",
        position: (6, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (6, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (6, 16),
        },
        Raw {
         content: "taskserver",
         position: (6, 25),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "taskd",
        position: (8, 3),
       },
      ],
     },
     String {
      parts: [
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (8, 14),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "taskserver",
            position: (8, 19),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "/bin/taskd",
        position: (8, 30),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkManualPkiOption",
        position: (10, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "desc",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "mkOption",
        position: (10, 29),
       },
       arguments: [
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "type",
              position: (11, 5),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "types",
              position: (11, 12),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "nullOr",
                position: (11, 18),
               },
              ],
             },
             default: None,
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (11, 25),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (11, 31),
                },
               ],
              },
              default: None,
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "default",
              position: (12, 5),
             },
            ],
           },
           Variable {
            identifier: "null",
            position: (12, 15),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "description",
              position: (13, 5),
             },
            ],
           },
           BinaryOperation {
            operator: Addition,
            operands: [
             Variable {
              identifier: "desc",
              position: (13, 19),
             },
             String {
              parts: [
               Raw {
                content: "<note><para>\nSetting this option will prevent automatic CA creation and handling.\n</para></note>\n",
                position: (14, 1),
               },
              ],
             },
            ],
            position: (13, 24),
           },
          ),
         ],
         recursive: false,
         position: (10, 38),
        },
       ],
      },
      position: (10, 23),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "manualPkiOptions",
        position: (20, 3),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "ca",
           position: (21, 5),
          },
          Raw {
           content: "cert",
           position: (21, 8),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkManualPkiOption",
          position: (21, 15),
         },
         arguments: [
          String {
           parts: [
            Raw {
             content: "Fully qualified path to the CA certificate.\n",
             position: (22, 1),
            },
           ],
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "server",
           position: (25, 5),
          },
          Raw {
           content: "cert",
           position: (25, 12),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkManualPkiOption",
          position: (25, 19),
         },
         arguments: [
          String {
           parts: [
            Raw {
             content: "Fully qualified path to the server certificate.\n",
             position: (26, 1),
            },
           ],
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "server",
           position: (29, 5),
          },
          Raw {
           content: "crl",
           position: (29, 12),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkManualPkiOption",
          position: (29, 18),
         },
         arguments: [
          String {
           parts: [
            Raw {
             content: "Fully qualified path to the server certificate revocation list.\n",
             position: (30, 1),
            },
           ],
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "server",
           position: (33, 5),
          },
          Raw {
           content: "key",
           position: (33, 12),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkManualPkiOption",
          position: (33, 18),
         },
         arguments: [
          String {
           parts: [
            Raw {
             content: "Fully qualified path to the server key.\n",
             position: (34, 1),
            },
           ],
          },
         ],
        },
       ),
      ],
      recursive: false,
      position: (20, 22),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkAutoDesc",
        position: (38, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "preamble",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: String {
       parts: [
        Raw {
         content: "",
         position: (39, 1),
        },
        Expression {
         expression: Variable {
          identifier: "preamble",
          position: (39, 7),
         },
        },
        Raw {
         content: "\n\n<note><para>\nThis option is for the automatically handled CA and will be ignored if any\nof the <option>services.taskserver.pki.manual.*</option> options are set.\n</para></note>\n",
         position: (39, 16),
        },
       ],
      },
      position: (38, 16),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkExpireOption",
        position: (47, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "desc",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "mkOption",
        position: (47, 26),
       },
       arguments: [
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "type",
              position: (48, 5),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "types",
              position: (48, 12),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "nullOr",
                position: (48, 18),
               },
              ],
             },
             default: None,
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (48, 25),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "int",
                 position: (48, 31),
                },
               ],
              },
              default: None,
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "default",
              position: (49, 5),
             },
            ],
           },
           Variable {
            identifier: "null",
            position: (49, 15),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "example",
              position: (50, 5),
             },
            ],
           },
           Int {
            value: 365,
            position: (50, 15),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "apply",
              position: (51, 5),
             },
            ],
           },
           Function {
            argument: Some(
             "val",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: IfThenElse {
             predicate: BinaryOperation {
              operator: EqualTo,
              operands: [
               Variable {
                identifier: "val",
                position: (51, 21),
               },
               Variable {
                identifier: "null",
                position: (51, 28),
               },
              ],
              position: (51, 25),
             },
             then: UnaryOperation {
              operator: Negate,
              operand: Int {
               value: 1,
               position: (51, 39),
              },
              position: (51, 38),
             },
             else_: Variable {
              identifier: "val",
              position: (51, 46),
             },
             position: (51, 18),
            },
            position: (51, 13),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "description",
              position: (52, 5),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkAutoDesc",
             position: (52, 19),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "The expiration time of ",
                position: (53, 1),
               },
               Expression {
                expression: Variable {
                 identifier: "desc",
                 position: (53, 32),
                },
               },
               Raw {
                content: " in days or <literal>null</literal> for no\nexpiration time.\n",
                position: (53, 37),
               },
              ],
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (47, 35),
        },
       ],
      },
      position: (47, 20),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "autoPkiOptions",
        position: (58, 3),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "bits",
           position: (59, 5),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (59, 12),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (60, 7),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (60, 14),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "int",
                 position: (60, 20),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "default",
                position: (61, 7),
               },
              ],
             },
             Int {
              value: 4096,
              position: (61, 17),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "example",
                position: (62, 7),
               },
              ],
             },
             Int {
              value: 2048,
              position: (62, 17),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (63, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkAutoDesc",
               position: (63, 21),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "The bit size for generated keys.",
                  position: (63, 33),
                 },
                ],
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (59, 21),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "expiration",
           position: (66, 5),
          },
         ],
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "ca",
              position: (67, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkExpireOption",
             position: (67, 12),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "the CA certificate",
                position: (67, 28),
               },
              ],
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "server",
              position: (68, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkExpireOption",
             position: (68, 16),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "the server certificate",
                position: (68, 32),
               },
              ],
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "client",
              position: (69, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkExpireOption",
             position: (69, 16),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "client certificates",
                position: (69, 32),
               },
              ],
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "crl",
              position: (70, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkExpireOption",
             position: (70, 13),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "the certificate revocation list (CRL)",
                position: (70, 29),
               },
              ],
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (66, 18),
        },
       ),
      ],
      recursive: false,
      position: (58, 20),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "needToCreateCA",
        position: (74, 3),
       },
      ],
     },
     LetIn {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "notFound",
           position: (75, 5),
          },
         ],
        },
        Function {
         argument: Some(
          "path",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: LetIn {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "dotted",
               position: (76, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "concatStringsSep",
              position: (76, 16),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: ".",
                 position: (76, 34),
                },
               ],
              },
              Variable {
               identifier: "path",
               position: (76, 37),
              },
             ],
            },
           ),
          ],
          target: FunctionApplication {
           function: Variable {
            identifier: "throw",
            position: (77, 8),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "Can't find option definitions for path `",
               position: (77, 15),
              },
              Expression {
               expression: Variable {
                identifier: "dotted",
                position: (77, 57),
               },
              },
              Raw {
               content: "'.",
               position: (77, 64),
              },
             ],
            },
           ],
          },
          position: (75, 22),
         },
         position: (75, 16),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "findPkiDefinitions",
           position: (78, 5),
          },
         ],
        },
        Function {
         argument: Some(
          "path",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: Function {
          argument: Some(
           "attrs",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: LetIn {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "mkSublist",
                position: (79, 7),
               },
              ],
             },
             Function {
              argument: Some(
               "key",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: Function {
               argument: Some(
                "val",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: LetIn {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "newPath",
                     position: (80, 9),
                    },
                   ],
                  },
                  BinaryOperation {
                   operator: Concatenation,
                   operands: [
                    Variable {
                     identifier: "path",
                     position: (80, 19),
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "singleton",
                      position: (80, 27),
                     },
                     arguments: [
                      Variable {
                       identifier: "key",
                       position: (80, 37),
                      },
                     ],
                    },
                   ],
                   position: (80, 24),
                  },
                 ),
                ],
                target: IfThenElse {
                 predicate: FunctionApplication {
                  function: Variable {
                   identifier: "isOption",
                   position: (81, 13),
                  },
                  arguments: [
                   Variable {
                    identifier: "val",
                    position: (81, 22),
                   },
                  ],
                 },
                 then: FunctionApplication {
                  function: Variable {
                   identifier: "attrByPath",
                   position: (82, 15),
                  },
                  arguments: [
                   Variable {
                    identifier: "newPath",
                    position: (82, 26),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "notFound",
                     position: (82, 35),
                    },
                    arguments: [
                     Variable {
                      identifier: "newPath",
                      position: (82, 44),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (82, 53),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "pki",
                       position: (82, 57),
                      },
                      Raw {
                       content: "manual",
                       position: (82, 61),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                 else_: FunctionApplication {
                  function: Variable {
                   identifier: "findPkiDefinitions",
                   position: (83, 15),
                  },
                  arguments: [
                   Variable {
                    identifier: "newPath",
                    position: (83, 34),
                   },
                   Variable {
                    identifier: "val",
                    position: (83, 42),
                   },
                  ],
                 },
                 position: (81, 10),
                },
                position: (79, 29),
               },
               position: (79, 24),
              },
              position: (79, 19),
             },
            ),
           ],
           target: FunctionApplication {
            function: Variable {
             identifier: "flatten",
             position: (84, 8),
            },
            arguments: [
             FunctionApplication {
              function: Variable {
               identifier: "mapAttrsToList",
               position: (84, 17),
              },
              arguments: [
               Variable {
                identifier: "mkSublist",
                position: (84, 32),
               },
               Variable {
                identifier: "attrs",
                position: (84, 42),
               },
              ],
             },
            ],
           },
           position: (78, 39),
          },
          position: (78, 32),
         },
         position: (78, 26),
        },
       ),
      ],
      target: FunctionApplication {
       function: Variable {
        identifier: "all",
        position: (85, 6),
       },
       arguments: [
        Function {
         argument: Some(
          "x",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: BinaryOperation {
          operator: EqualTo,
          operands: [
           Variable {
            identifier: "x",
            position: (85, 14),
           },
           Variable {
            identifier: "null",
            position: (85, 19),
           },
          ],
          position: (85, 16),
         },
         position: (85, 11),
        },
        FunctionApplication {
         function: Variable {
          identifier: "findPkiDefinitions",
          position: (85, 26),
         },
         arguments: [
          List {
           elements: [],
           position: (85, 45),
          },
          Variable {
           identifier: "manualPkiOptions",
           position: (85, 48),
          },
         ],
        },
       ],
      },
      position: (74, 20),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "orgOptions",
        position: (87, 3),
       },
      ],
     },
     Function {
      argument: None,
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: true,
      },
      definition: Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "options",
            position: (88, 5),
           },
           Raw {
            content: "users",
            position: (88, 13),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (88, 21),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (89, 7),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (89, 14),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "uniq",
                   position: (89, 20),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (89, 26),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "listOf",
                     position: (89, 32),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (89, 39),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "str",
                      position: (89, 45),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (90, 7),
                },
               ],
              },
              List {
               elements: [],
               position: (90, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (91, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "alice",
                   position: (91, 20),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "bob",
                   position: (91, 28),
                  },
                 ],
                },
               ],
               position: (91, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (92, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "A list of user names that belong to the organization.\n",
                 position: (93, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (88, 30),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "options",
            position: (97, 5),
           },
           Raw {
            content: "groups",
            position: (97, 13),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (97, 22),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (98, 7),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (98, 14),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "listOf",
                   position: (98, 20),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (98, 27),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "str",
                    position: (98, 33),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (99, 7),
                },
               ],
              },
              List {
               elements: [],
               position: (99, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (100, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "workers",
                   position: (100, 20),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "slackers",
                   position: (100, 30),
                  },
                 ],
                },
               ],
               position: (100, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (101, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "A list of group names that belong to the organization.\n",
                 position: (102, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (97, 31),
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (87, 25),
      },
      position: (87, 16),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "certtool",
        position: (107, 3),
       },
      ],
     },
     String {
      parts: [
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (107, 17),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "gnutls",
            position: (107, 22),
           },
           Raw {
            content: "bin",
            position: (107, 29),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "/bin/certtool",
        position: (107, 33),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "nixos-taskserver",
        position: (109, 3),
       },
      ],
     },
     With {
      expression: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (109, 27),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "python2",
          position: (109, 32),
         },
         Raw {
          content: "pkgs",
          position: (109, 40),
         },
        ],
       },
       default: None,
      },
      target: FunctionApplication {
       function: Variable {
        identifier: "buildPythonApplication",
        position: (109, 46),
       },
       arguments: [
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "name",
              position: (110, 5),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "nixos-taskserver",
              position: (110, 13),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "src",
              position: (112, 5),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "pkgs",
              position: (112, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "runCommand",
                position: (112, 16),
               },
              ],
             },
             default: None,
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "nixos-taskserver-src",
                position: (112, 28),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "preferLocalBuild",
                   position: (112, 52),
                  },
                 ],
                },
                Variable {
                 identifier: "true",
                 position: (112, 71),
                },
               ),
              ],
              recursive: false,
              position: (112, 50),
             },
             String {
              parts: [
               Raw {
                content: "mkdir -p \"$out\"\ncat \"",
                position: (113, 1),
               },
               Expression {
                expression: FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (114, 14),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "substituteAll",
                     position: (114, 19),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "src",
                        position: (115, 9),
                       },
                      ],
                     },
                     Path {
                      parts: [
                       Raw {
                        content: "./helper-tool.py",
                        position: (115, 15),
                       },
                      ],
                     },
                    ),
                    Inherit(
                     None,
                     [
                      Raw {
                       content: "taskd",
                       position: (116, 17),
                      },
                      Raw {
                       content: "certtool",
                       position: (116, 23),
                      },
                     ],
                    ),
                    Inherit(
                     Some(
                      Variable {
                       identifier: "cfg",
                       position: (117, 18),
                      },
                     ),
                     [
                      Raw {
                       content: "dataDir",
                       position: (117, 23),
                      },
                      Raw {
                       content: "user",
                       position: (117, 31),
                      },
                      Raw {
                       content: "group",
                       position: (117, 36),
                      },
                      Raw {
                       content: "fqdn",
                       position: (117, 42),
                      },
                     ],
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "certBits",
                        position: (118, 9),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (118, 20),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "pki",
                         position: (118, 24),
                        },
                        Raw {
                         content: "auto",
                         position: (118, 28),
                        },
                        Raw {
                         content: "bits",
                         position: (118, 33),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "clientExpiration",
                        position: (119, 9),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (119, 28),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "pki",
                         position: (119, 32),
                        },
                        Raw {
                         content: "auto",
                         position: (119, 36),
                        },
                        Raw {
                         content: "expiration",
                         position: (119, 41),
                        },
                        Raw {
                         content: "client",
                         position: (119, 52),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "crlExpiration",
                        position: (120, 9),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (120, 25),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "pki",
                         position: (120, 29),
                        },
                        Raw {
                         content: "auto",
                         position: (120, 33),
                        },
                        Raw {
                         content: "expiration",
                         position: (120, 38),
                        },
                        Raw {
                         content: "crl",
                         position: (120, 49),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "isAutoConfig",
                        position: (121, 9),
                       },
                      ],
                     },
                     IfThenElse {
                      predicate: Variable {
                       identifier: "needToCreateCA",
                       position: (121, 27),
                      },
                      then: String {
                       parts: [
                        Raw {
                         content: "True",
                         position: (121, 48),
                        },
                       ],
                      },
                      else_: String {
                       parts: [
                        Raw {
                         content: "False",
                         position: (121, 60),
                        },
                       ],
                      },
                      position: (121, 24),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (114, 33),
                  },
                 ],
                },
               },
               Raw {
                content: "\" > \"$out/main.py\"\ncat > \"$out/setup.py\" <<EOF\nfrom setuptools import setup\nsetup(name=\"nixos-taskserver\",\n      py_modules=[\"main\"],\n      install_requires=[\"Click\"],\n      entry_points=\"[console_scripts]\\\\nnixos-taskserver=main:cli\")\nEOF\n",
                position: (122, 9),
               },
              ],
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "propagatedBuildInputs",
              position: (132, 5),
             },
            ],
           },
           List {
            elements: [
             Variable {
              identifier: "click",
              position: (132, 31),
             },
            ],
            position: (132, 29),
           },
          ),
         ],
         recursive: false,
         position: (109, 69),
        },
       ],
      },
      position: (109, 22),
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (136, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "services",
            position: (137, 5),
           },
           Raw {
            content: "taskserver",
            position: (137, 14),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (138, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (138, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (139, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (139, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (139, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (140, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (140, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (141, 9),
                   },
                  ],
                 },
                 LetIn {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "url",
                       position: (142, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "https://nixos.org/manual/nixos/stable/index.html#module-services-taskserver",
                       position: (142, 18),
                      },
                     ],
                    },
                   ),
                  ],
                  target: String {
                   parts: [
                    Raw {
                     content: "Whether to enable the Taskwarrior server.\n\nMore instructions about NixOS in conjuction with Taskserver can be\nfound <link xlink:href=\"",
                     position: (144, 1),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "url",
                      position: (147, 37),
                     },
                    },
                    Raw {
                     content: "\">in the NixOS manual</link>.\n",
                     position: (147, 41),
                    },
                   ],
                  },
                  position: (141, 23),
                 },
                ),
               ],
               recursive: false,
               position: (138, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "user",
               position: (151, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (151, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (152, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (152, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (152, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (153, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "taskd",
                    position: (153, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (154, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "User for Taskserver.",
                    position: (154, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (151, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "group",
               position: (157, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (157, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (158, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (158, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (158, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (159, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "taskd",
                    position: (159, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (160, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Group for Taskserver.",
                    position: (160, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (157, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "dataDir",
               position: (163, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (163, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (164, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (164, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "path",
                     position: (164, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (165, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/var/lib/taskserver",
                    position: (165, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (166, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Data directory for Taskserver.",
                    position: (166, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (163, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "ciphers",
               position: (169, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (169, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (170, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (170, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (170, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (170, 30),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "separatedString",
                        position: (170, 36),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: ":",
                        position: (170, 53),
                       },
                      ],
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (171, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (171, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (172, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "NORMAL:-VERS-SSL3.0",
                    position: (172, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (173, 9),
                   },
                  ],
                 },
                 LetIn {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "url",
                       position: (174, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "https://gnutls.org/manual/html_node/Priority-Strings.html",
                       position: (174, 18),
                      },
                     ],
                    },
                   ),
                  ],
                  target: String {
                   parts: [
                    Raw {
                     content: "List of GnuTLS ciphers to use. See the GnuTLS documentation about\npriority strings at <link xlink:href=\"",
                     position: (176, 1),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "url",
                      position: (177, 51),
                     },
                    },
                    Raw {
                     content: "\"/> for full details.\n",
                     position: (177, 55),
                    },
                   ],
                  },
                  position: (173, 23),
                 },
                ),
               ],
               recursive: false,
               position: (169, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "organisations",
               position: (181, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (181, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (182, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (182, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "attrsOf",
                      position: (182, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (182, 31),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "submodule",
                        position: (182, 37),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     Variable {
                      identifier: "orgOptions",
                      position: (182, 47),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (183, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (183, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (184, 9),
                   },
                   Raw {
                    content: "myShinyOrganisation",
                    position: (184, 17),
                   },
                   Raw {
                    content: "users",
                    position: (184, 37),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "alice",
                      position: (184, 48),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "bob",
                      position: (184, 56),
                     },
                    ],
                   },
                  ],
                  position: (184, 45),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (185, 9),
                   },
                   Raw {
                    content: "myShinyOrganisation",
                    position: (185, 17),
                   },
                   Raw {
                    content: "groups",
                    position: (185, 37),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "staff",
                      position: (185, 49),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "outsiders",
                      position: (185, 57),
                     },
                    ],
                   },
                  ],
                  position: (185, 46),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (186, 9),
                   },
                   Raw {
                    content: "yetAnotherOrganisation",
                    position: (186, 17),
                   },
                   Raw {
                    content: "users",
                    position: (186, 40),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "foo",
                      position: (186, 51),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "bar",
                      position: (186, 57),
                     },
                    ],
                   },
                  ],
                  position: (186, 48),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (187, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "An attribute set where the keys name the organisation and the values\nare a set of lists of <option>users</option> and\n<option>groups</option>.\n",
                    position: (188, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (181, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "confirmation",
               position: (194, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (194, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (195, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (195, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (195, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (196, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (196, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (197, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Determines whether certain commands are confirmed.\n",
                    position: (198, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (194, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "debug",
               position: (202, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (202, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (203, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (203, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (203, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (204, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (204, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (205, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Logs debugging information.\n",
                    position: (206, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (202, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extensions",
               position: (210, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (210, 20),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (211, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (211, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (211, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (211, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "path",
                       position: (211, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (212, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (212, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (213, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Fully qualified path of the Taskserver extension scripts.\nCurrently there are none.\n",
                    position: (214, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (210, 29),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "ipLog",
               position: (219, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (219, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (220, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (220, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (220, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (221, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (221, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (222, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Logs the IP addresses of incoming requests.\n",
                    position: (223, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (219, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "queueSize",
               position: (227, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (227, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (228, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (228, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (228, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (229, 9),
                   },
                  ],
                 },
                 Int {
                  value: 10,
                  position: (229, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (230, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Size of the connection backlog, see <citerefentry>\n  <refentrytitle>listen</refentrytitle>\n  <manvolnum>2</manvolnum>\n</citerefentry>.\n",
                    position: (231, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (227, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "requestLimit",
               position: (238, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (238, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (239, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (239, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (239, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (240, 9),
                   },
                  ],
                 },
                 Int {
                  value: 1048576,
                  position: (240, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (241, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Size limit of incoming requests, in bytes.\n",
                    position: (242, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (238, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "allowedClientIDs",
               position: (246, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (246, 26),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (247, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (247, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "either",
                    position: (247, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "str",
                     position: (247, 35),
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "listOf",
                      position: (247, 40),
                     },
                     arguments: [
                      Variable {
                       identifier: "str",
                       position: (247, 47),
                      },
                     ],
                    },
                   ],
                  },
                  position: (247, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (248, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (248, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (249, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "[Tt]ask [2-9]+",
                      position: (249, 22),
                     },
                    ],
                   },
                  ],
                  position: (249, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (250, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "A list of regular expressions that are matched against the reported\nclient id (such as <literal>task 2.3.0</literal>).\n\nThe values <literal>all</literal> or <literal>none</literal> have\nspecial meaning. Overidden by any entry in the option\n<option>services.taskserver.disallowedClientIDs</option>.\n",
                    position: (251, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (246, 35),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "disallowedClientIDs",
               position: (260, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (260, 29),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (261, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (261, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "either",
                    position: (261, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "str",
                     position: (261, 35),
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "listOf",
                      position: (261, 40),
                     },
                     arguments: [
                      Variable {
                       identifier: "str",
                       position: (261, 47),
                      },
                     ],
                    },
                   ],
                  },
                  position: (261, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (262, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (262, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (263, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "[Tt]ask [2-9]+",
                      position: (263, 22),
                     },
                    ],
                   },
                  ],
                  position: (263, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (264, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "A list of regular expressions that are matched against the reported\nclient id (such as <literal>task 2.3.0</literal>).\n\nThe values <literal>all</literal> or <literal>none</literal> have\nspecial meaning. Any entry here overrides those in\n<option>services.taskserver.allowedClientIDs</option>.\n",
                    position: (265, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (260, 38),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "listenHost",
               position: (274, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (274, 20),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (275, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (275, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (275, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (276, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "localhost",
                    position: (276, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (277, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "::",
                    position: (277, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (278, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The address (IPv4, IPv6 or DNS) to listen on.\n\nIf the value is something else than <literal>localhost</literal> the\nport defined by <option>listenPort</option> is automatically added to\n<option>networking.firewall.allowedTCPPorts</option>.\n",
                    position: (279, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (274, 29),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "listenPort",
               position: (287, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (287, 20),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (288, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (288, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (288, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (289, 9),
                   },
                  ],
                 },
                 Int {
                  value: 53589,
                  position: (289, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (290, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Port number of the Taskserver.\n",
                    position: (291, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (287, 29),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "fqdn",
               position: (295, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (295, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (296, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (296, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (296, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (297, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "localhost",
                    position: (297, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (298, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The fully qualified domain name of this server, which is also used\nas the common name in the certificates.\n",
                    position: (299, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (295, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "trust",
               position: (304, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (304, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (305, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (305, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "enum",
                      position: (305, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "allow all",
                        position: (305, 30),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "strict",
                        position: (305, 42),
                       },
                      ],
                     },
                    ],
                    position: (305, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (306, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "strict",
                    position: (306, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (307, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Determines how client certificates are validated.\n\nThe value <literal>allow all</literal> performs no client\ncertificate validation. This is not recommended. The value\n<literal>strict</literal> causes the client certificate to be\nvalidated against a CA.\n",
                    position: (308, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (304, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "pki",
               position: (317, 7),
              },
              Raw {
               content: "manual",
               position: (317, 11),
              },
             ],
            },
            Variable {
             identifier: "manualPkiOptions",
             position: (317, 20),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "pki",
               position: (318, 7),
              },
              Raw {
               content: "auto",
               position: (318, 11),
              },
             ],
            },
            Variable {
             identifier: "autoPkiOptions",
             position: (318, 18),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "config",
               position: (320, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (320, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (321, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (321, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "attrs",
                     position: (321, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (322, 9),
                   },
                   Raw {
                    content: "client",
                    position: (322, 17),
                   },
                   Raw {
                    content: "cert",
                    position: (322, 24),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/tmp/debugging.cert",
                    position: (322, 32),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (323, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Configuration options to pass to Taskserver.\n\nThe options here are the same as described in <citerefentry>\n  <refentrytitle>taskdrc</refentrytitle>\n  <manvolnum>5</manvolnum>\n</citerefentry>, but with one difference:\n\nThe <literal>server</literal> option is\n<literal>server.listen</literal> here, because the\n<literal>server</literal> option would collide with other options\nlike <literal>server.cert</literal> and we would run in a type error\n(attribute set versus string).\n\nNix types like integers or booleans are automatically converted to\nthe right values Taskserver would expect.\n",
                    position: (324, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "apply",
                    position: (340, 9),
                   },
                  ],
                 },
                 LetIn {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "mkKey",
                       position: (341, 11),
                      },
                     ],
                    },
                    Function {
                     argument: Some(
                      "path",
                     ),
                     arguments: FunctionArguments {
                      arguments: [],
                      ellipsis: false,
                     },
                     definition: IfThenElse {
                      predicate: BinaryOperation {
                       operator: EqualTo,
                       operands: [
                        Variable {
                         identifier: "path",
                         position: (341, 28),
                        },
                        List {
                         elements: [
                          String {
                           parts: [
                            Raw {
                             content: "server",
                             position: (341, 38),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "listen",
                             position: (341, 47),
                            },
                           ],
                          },
                         ],
                         position: (341, 36),
                        },
                       ],
                       position: (341, 33),
                      },
                      then: String {
                       parts: [
                        Raw {
                         content: "server",
                         position: (341, 62),
                        },
                       ],
                      },
                      else_: FunctionApplication {
                       function: Variable {
                        identifier: "concatStringsSep",
                        position: (342, 30),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: ".",
                           position: (342, 48),
                          },
                         ],
                        },
                        Variable {
                         identifier: "path",
                         position: (342, 51),
                        },
                       ],
                      },
                      position: (341, 25),
                     },
                     position: (341, 19),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "recurse",
                       position: (343, 11),
                      },
                     ],
                    },
                    Function {
                     argument: Some(
                      "path",
                     ),
                     arguments: FunctionArguments {
                      arguments: [],
                      ellipsis: false,
                     },
                     definition: Function {
                      argument: Some(
                       "attrs",
                      ),
                      arguments: FunctionArguments {
                       arguments: [],
                       ellipsis: false,
                      },
                      definition: LetIn {
                       bindings: [
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "mapper",
                            position: (344, 13),
                           },
                          ],
                         },
                         Function {
                          argument: Some(
                           "name",
                          ),
                          arguments: FunctionArguments {
                           arguments: [],
                           ellipsis: false,
                          },
                          definition: Function {
                           argument: Some(
                            "val",
                           ),
                           arguments: FunctionArguments {
                            arguments: [],
                            ellipsis: false,
                           },
                           definition: LetIn {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "newPath",
                                 position: (345, 15),
                                },
                               ],
                              },
                              BinaryOperation {
                               operator: Concatenation,
                               operands: [
                                Variable {
                                 identifier: "path",
                                 position: (345, 25),
                                },
                                List {
                                 elements: [
                                  Variable {
                                   identifier: "name",
                                   position: (345, 35),
                                  },
                                 ],
                                 position: (345, 33),
                                },
                               ],
                               position: (345, 30),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "scalar",
                                 position: (346, 15),
                                },
                               ],
                              },
                              IfThenElse {
                               predicate: BinaryOperation {
                                operator: EqualTo,
                                operands: [
                                 Variable {
                                  identifier: "val",
                                  position: (346, 27),
                                 },
                                 Variable {
                                  identifier: "true",
                                  position: (346, 34),
                                 },
                                ],
                                position: (346, 31),
                               },
                               then: String {
                                parts: [
                                 Raw {
                                  content: "true",
                                  position: (346, 45),
                                 },
                                ],
                               },
                               else_: IfThenElse {
                                predicate: BinaryOperation {
                                 operator: EqualTo,
                                 operands: [
                                  Variable {
                                   identifier: "val",
                                   position: (347, 32),
                                  },
                                  Variable {
                                   identifier: "false",
                                   position: (347, 39),
                                  },
                                 ],
                                 position: (347, 36),
                                },
                                then: String {
                                 parts: [
                                  Raw {
                                   content: "false",
                                   position: (347, 51),
                                  },
                                 ],
                                },
                                else_: FunctionApplication {
                                 function: Variable {
                                  identifier: "toString",
                                  position: (348, 29),
                                 },
                                 arguments: [
                                  Variable {
                                   identifier: "val",
                                   position: (348, 38),
                                  },
                                 ],
                                },
                                position: (347, 29),
                               },
                               position: (346, 24),
                              },
                             ),
                            ],
                            target: IfThenElse {
                             predicate: FunctionApplication {
                              function: Variable {
                               identifier: "isAttrs",
                               position: (349, 19),
                              },
                              arguments: [
                               Variable {
                                identifier: "val",
                                position: (349, 27),
                               },
                              ],
                             },
                             then: FunctionApplication {
                              function: Variable {
                               identifier: "recurse",
                               position: (349, 36),
                              },
                              arguments: [
                               Variable {
                                identifier: "newPath",
                                position: (349, 44),
                               },
                               Variable {
                                identifier: "val",
                                position: (349, 52),
                               },
                              ],
                             },
                             else_: List {
                              elements: [
                               String {
                                parts: [
                                 Expression {
                                  expression: FunctionApplication {
                                   function: Variable {
                                    identifier: "mkKey",
                                    position: (350, 26),
                                   },
                                   arguments: [
                                    Variable {
                                     identifier: "newPath",
                                     position: (350, 32),
                                    },
                                   ],
                                  },
                                 },
                                 Raw {
                                  content: "=",
                                  position: (350, 40),
                                 },
                                 Expression {
                                  expression: Variable {
                                   identifier: "scalar",
                                   position: (350, 43),
                                  },
                                 },
                                ],
                               },
                              ],
                              position: (350, 21),
                             },
                             position: (349, 16),
                            },
                            position: (344, 33),
                           },
                           position: (344, 28),
                          },
                          position: (344, 22),
                         },
                        ),
                       ],
                       target: FunctionApplication {
                        function: Variable {
                         identifier: "concatLists",
                         position: (351, 14),
                        },
                        arguments: [
                         FunctionApplication {
                          function: Variable {
                           identifier: "mapAttrsToList",
                           position: (351, 27),
                          },
                          arguments: [
                           Variable {
                            identifier: "mapper",
                            position: (351, 42),
                           },
                           Variable {
                            identifier: "attrs",
                            position: (351, 49),
                           },
                          ],
                         },
                        ],
                       },
                       position: (343, 34),
                      },
                      position: (343, 27),
                     },
                     position: (343, 21),
                    },
                   ),
                  ],
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "recurse",
                    position: (352, 12),
                   },
                   arguments: [
                    List {
                     elements: [],
                     position: (352, 20),
                    },
                   ],
                  },
                  position: (340, 17),
                 },
                ),
               ],
               recursive: false,
               position: (320, 25),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (137, 27),
         },
        ),
       ],
       recursive: false,
       position: (136, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "imports",
         position: (357, 3),
        },
       ],
      },
      List {
       elements: [
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (358, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (358, 30),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "taskserver",
               position: (358, 41),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "extraConfig",
               position: (358, 54),
              },
             ],
            },
           ],
           position: (358, 28),
          },
          String {
           parts: [
            Raw {
             content: "This option was removed in favor of `services.taskserver.config` with\ndifferent semantics (it's now a list of attributes instead of lines).\n\nPlease look up the documentation of `services.taskserver.config' to get\nmore information about the new way to pass additional configuration\noptions.\n",
             position: (359, 1),
            },
           ],
          },
         ],
        },
       ],
       position: (357, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (368, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkMerge",
        position: (368, 12),
       },
       arguments: [
        List {
         elements: [
          FunctionApplication {
           function: Variable {
            identifier: "mkIf",
            position: (369, 6),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (369, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "enable",
                position: (369, 15),
               },
              ],
             },
             default: None,
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "environment",
                  position: (370, 7),
                 },
                 Raw {
                  content: "systemPackages",
                  position: (370, 19),
                 },
                ],
               },
               List {
                elements: [
                 Variable {
                  identifier: "nixos-taskserver",
                  position: (370, 38),
                 },
                ],
                position: (370, 36),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "users",
                  position: (372, 7),
                 },
                 Raw {
                  content: "users",
                  position: (372, 13),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "optionalAttrs",
                 position: (372, 21),
                },
                arguments: [
                 BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (372, 36),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "user",
                       position: (372, 40),
                      },
                     ],
                    },
                    default: None,
                   },
                   String {
                    parts: [
                     Raw {
                      content: "taskd",
                      position: (372, 49),
                     },
                    ],
                   },
                  ],
                  position: (372, 45),
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "taskd",
                       position: (373, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "uid",
                          position: (374, 11),
                         },
                        ],
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "config",
                         position: (374, 17),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "ids",
                           position: (374, 24),
                          },
                          Raw {
                           content: "uids",
                           position: (374, 28),
                          },
                          Raw {
                           content: "taskd",
                           position: (374, 33),
                          },
                         ],
                        },
                        default: None,
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "description",
                          position: (375, 11),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "Taskserver user",
                          position: (375, 26),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "group",
                          position: (376, 11),
                         },
                        ],
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (376, 19),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "group",
                           position: (376, 23),
                          },
                         ],
                        },
                        default: None,
                       },
                      ),
                     ],
                     recursive: false,
                     position: (373, 17),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (372, 57),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "users",
                  position: (380, 7),
                 },
                 Raw {
                  content: "groups",
                  position: (380, 13),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "optionalAttrs",
                 position: (380, 22),
                },
                arguments: [
                 BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (380, 37),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "group",
                       position: (380, 41),
                      },
                     ],
                    },
                    default: None,
                   },
                   String {
                    parts: [
                     Raw {
                      content: "taskd",
                      position: (380, 51),
                     },
                    ],
                   },
                  ],
                  position: (380, 47),
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "taskd",
                       position: (381, 9),
                      },
                      Raw {
                       content: "gid",
                       position: (381, 15),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (381, 21),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "ids",
                        position: (381, 28),
                       },
                       Raw {
                        content: "gids",
                        position: (381, 32),
                       },
                       Raw {
                        content: "taskd",
                        position: (381, 37),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                  ],
                  recursive: false,
                  position: (380, 59),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "services",
                  position: (384, 7),
                 },
                 Raw {
                  content: "taskserver",
                  position: (384, 16),
                 },
                 Raw {
                  content: "config",
                  position: (384, 27),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "daemon",
                     position: (386, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "false",
                   position: (386, 18),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "log",
                     position: (387, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "-",
                     position: (387, 16),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "debug",
                     position: (390, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (390, 17),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "debug",
                      position: (390, 21),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "ip",
                     position: (391, 9),
                    },
                    Raw {
                     content: "log",
                     position: (391, 12),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (391, 18),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "ipLog",
                      position: (391, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "ciphers",
                     position: (394, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (394, 19),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "ciphers",
                      position: (394, 23),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "confirmation",
                     position: (395, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (395, 24),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "confirmation",
                      position: (395, 28),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "extensions",
                     position: (396, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (396, 22),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "extensions",
                      position: (396, 26),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "queue",
                     position: (397, 9),
                    },
                    Raw {
                     content: "size",
                     position: (397, 15),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (397, 22),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "queueSize",
                      position: (397, 26),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "request",
                     position: (398, 9),
                    },
                    Raw {
                     content: "limit",
                     position: (398, 17),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (398, 25),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "requestLimit",
                      position: (398, 29),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "client",
                     position: (401, 9),
                    },
                    Raw {
                     content: "allow",
                     position: (401, 16),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (401, 24),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "allowedClientIDs",
                      position: (401, 28),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "client",
                     position: (402, 9),
                    },
                    Raw {
                     content: "deny",
                     position: (402, 16),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (402, 23),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "disallowedClientIDs",
                      position: (402, 27),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "trust",
                     position: (405, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (405, 17),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "trust",
                      position: (405, 21),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "server",
                     position: (406, 9),
                    },
                   ],
                  },
                  BinaryOperation {
                   operator: Update,
                   operands: [
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "listen",
                          position: (407, 11),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (407, 23),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "listenHost",
                              position: (407, 27),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: ":",
                          position: (407, 38),
                         },
                         Expression {
                          expression: FunctionApplication {
                           function: Variable {
                            identifier: "toString",
                            position: (407, 41),
                           },
                           arguments: [
                            PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (407, 50),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "listenPort",
                                position: (407, 54),
                               },
                              ],
                             },
                             default: None,
                            },
                           ],
                          },
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (406, 18),
                    },
                    IfThenElse {
                     predicate: Variable {
                      identifier: "needToCreateCA",
                      position: (408, 18),
                     },
                     then: Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "cert",
                           position: (409, 11),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (409, 21),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "dataDir",
                               position: (409, 25),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "/keys/server.cert",
                           position: (409, 33),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "key",
                           position: (410, 11),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (410, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "dataDir",
                               position: (410, 24),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "/keys/server.key",
                           position: (410, 32),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "crl",
                           position: (411, 11),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (411, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "dataDir",
                               position: (411, 24),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "/keys/server.crl",
                           position: (411, 32),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (408, 38),
                     },
                     else_: Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "cert",
                           position: (413, 11),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (413, 21),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "pki",
                               position: (413, 25),
                              },
                              Raw {
                               content: "manual",
                               position: (413, 29),
                              },
                              Raw {
                               content: "server",
                               position: (413, 36),
                              },
                              Raw {
                               content: "cert",
                               position: (413, 43),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "key",
                           position: (414, 11),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (414, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "pki",
                               position: (414, 24),
                              },
                              Raw {
                               content: "manual",
                               position: (414, 28),
                              },
                              Raw {
                               content: "server",
                               position: (414, 35),
                              },
                              Raw {
                               content: "key",
                               position: (414, 42),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Expression {
                           expression: FunctionApplication {
                            function: Variable {
                             identifier: "mapNullable",
                             position: (415, 13),
                            },
                            arguments: [
                             Function {
                              argument: Some(
                               "_",
                              ),
                              arguments: FunctionArguments {
                               arguments: [],
                               ellipsis: false,
                              },
                              definition: String {
                               parts: [
                                Raw {
                                 content: "crl",
                                 position: (415, 30),
                                },
                               ],
                              },
                              position: (415, 26),
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "cfg",
                               position: (415, 36),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "pki",
                                 position: (415, 40),
                                },
                                Raw {
                                 content: "manual",
                                 position: (415, 44),
                                },
                                Raw {
                                 content: "server",
                                 position: (415, 51),
                                },
                                Raw {
                                 content: "crl",
                                 position: (415, 58),
                                },
                               ],
                              },
                              default: None,
                             },
                            ],
                           },
                          },
                         ],
                        },
                        String {
                         parts: [
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (415, 68),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "pki",
                               position: (415, 72),
                              },
                              Raw {
                               content: "manual",
                               position: (415, 76),
                              },
                              Raw {
                               content: "server",
                               position: (415, 83),
                              },
                              Raw {
                               content: "crl",
                               position: (415, 90),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (412, 16),
                     },
                     position: (408, 15),
                    },
                   ],
                   position: (408, 11),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "ca",
                     position: (418, 9),
                    },
                    Raw {
                     content: "cert",
                     position: (418, 12),
                    },
                   ],
                  },
                  IfThenElse {
                   predicate: Variable {
                    identifier: "needToCreateCA",
                    position: (418, 22),
                   },
                   then: String {
                    parts: [
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (418, 45),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "dataDir",
                          position: (418, 49),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys/ca.cert",
                      position: (418, 57),
                     },
                    ],
                   },
                   else_: String {
                    parts: [
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (419, 27),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "pki",
                          position: (419, 31),
                         },
                         Raw {
                          content: "manual",
                          position: (419, 35),
                         },
                         Raw {
                          content: "ca",
                          position: (419, 42),
                         },
                         Raw {
                          content: "cert",
                          position: (419, 45),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                    ],
                   },
                   position: (418, 19),
                  },
                 ),
                ],
                recursive: false,
                position: (384, 36),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "systemd",
                  position: (422, 7),
                 },
                 Raw {
                  content: "services",
                  position: (422, 15),
                 },
                 Raw {
                  content: "taskserver-init",
                  position: (422, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "wantedBy",
                     position: (423, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "taskserver.service",
                       position: (423, 23),
                      },
                     ],
                    },
                   ],
                   position: (423, 20),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "before",
                     position: (424, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "taskserver.service",
                       position: (424, 21),
                      },
                     ],
                    },
                   ],
                   position: (424, 18),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (425, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Initialize Taskserver Data Directory",
                     position: (425, 24),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "preStart",
                     position: (427, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "mkdir -m 0770 -p \"",
                     position: (428, 1),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (428, 31),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (428, 35),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "\"\nchown \"",
                     position: (428, 43),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (429, 20),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "user",
                         position: (429, 24),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: ":",
                     position: (429, 29),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (429, 32),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "group",
                         position: (429, 36),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "\" \"",
                     position: (429, 42),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (429, 47),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (429, 51),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "\"\n",
                     position: (429, 59),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "script",
                     position: (432, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "",
                     position: (433, 1),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "taskd",
                      position: (433, 13),
                     },
                    },
                    Raw {
                     content: " init\ntouch \"",
                     position: (433, 19),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (434, 20),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (434, 24),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/.is_initialized\"\n",
                     position: (434, 32),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "environment",
                     position: (437, 9),
                    },
                    Raw {
                     content: "TASKDDATA",
                     position: (437, 21),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (437, 33),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "dataDir",
                      position: (437, 37),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "unitConfig",
                     position: (439, 9),
                    },
                    Raw {
                     content: "ConditionPathExists",
                     position: (439, 20),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "!",
                     position: (439, 43),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (439, 46),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (439, 50),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/.is_initialized",
                     position: (439, 58),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "serviceConfig",
                     position: (441, 9),
                    },
                    Raw {
                     content: "Type",
                     position: (441, 23),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "oneshot",
                     position: (441, 31),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "serviceConfig",
                     position: (442, 9),
                    },
                    Raw {
                     content: "User",
                     position: (442, 23),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (442, 30),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "user",
                      position: (442, 34),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "serviceConfig",
                     position: (443, 9),
                    },
                    Raw {
                     content: "Group",
                     position: (443, 23),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (443, 31),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "group",
                      position: (443, 35),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "serviceConfig",
                     position: (444, 9),
                    },
                    Raw {
                     content: "PermissionsStartOnly",
                     position: (444, 23),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (444, 46),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "serviceConfig",
                     position: (445, 9),
                    },
                    Raw {
                     content: "PrivateNetwork",
                     position: (445, 23),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (445, 40),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "serviceConfig",
                     position: (446, 9),
                    },
                    Raw {
                     content: "PrivateDevices",
                     position: (446, 23),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (446, 40),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "serviceConfig",
                     position: (447, 9),
                    },
                    Raw {
                     content: "PrivateTmp",
                     position: (447, 23),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (447, 36),
                  },
                 ),
                ],
                recursive: false,
                position: (422, 42),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "systemd",
                  position: (450, 7),
                 },
                 Raw {
                  content: "services",
                  position: (450, 15),
                 },
                 Raw {
                  content: "taskserver",
                  position: (450, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (451, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Taskwarrior Server",
                     position: (451, 24),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "wantedBy",
                     position: (453, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "multi-user.target",
                       position: (453, 23),
                      },
                     ],
                    },
                   ],
                   position: (453, 20),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "after",
                     position: (454, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "network.target",
                       position: (454, 20),
                      },
                     ],
                    },
                   ],
                   position: (454, 17),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "environment",
                     position: (456, 9),
                    },
                    Raw {
                     content: "TASKDDATA",
                     position: (456, 21),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (456, 33),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "dataDir",
                      position: (456, 37),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "preStart",
                     position: (458, 9),
                    },
                   ],
                  },
                  LetIn {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "jsonOrgs",
                        position: (459, 11),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "builtins",
                        position: (459, 22),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "toJSON",
                          position: (459, 31),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (459, 38),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "organisations",
                           position: (459, 42),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "jsonFile",
                        position: (460, 11),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (460, 22),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "writeText",
                          position: (460, 27),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "orgs.json",
                          position: (460, 38),
                         },
                        ],
                       },
                       Variable {
                        identifier: "jsonOrgs",
                        position: (460, 49),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "helperTool",
                        position: (461, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Expression {
                        expression: Variable {
                         identifier: "nixos-taskserver",
                         position: (461, 27),
                        },
                       },
                       Raw {
                        content: "/bin/nixos-taskserver",
                        position: (461, 44),
                       },
                      ],
                     },
                    ),
                   ],
                   target: String {
                    parts: [
                     Expression {
                      expression: Variable {
                       identifier: "helperTool",
                       position: (462, 15),
                      },
                     },
                     Raw {
                      content: " process-json '",
                      position: (462, 26),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "jsonFile",
                       position: (462, 43),
                      },
                     },
                     Raw {
                      content: "'",
                      position: (462, 52),
                     },
                    ],
                   },
                   position: (458, 20),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "serviceConfig",
                     position: (464, 9),
                    },
                   ],
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "ExecStart",
                        position: (465, 11),
                       },
                      ],
                     },
                     LetIn {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "mkCfgFlag",
                           position: (466, 13),
                          },
                         ],
                        },
                        Function {
                         argument: Some(
                          "flag",
                         ),
                         arguments: FunctionArguments {
                          arguments: [],
                          ellipsis: false,
                         },
                         definition: FunctionApplication {
                          function: Variable {
                           identifier: "escapeShellArg",
                           position: (466, 31),
                          },
                          arguments: [
                           String {
                            parts: [
                             Raw {
                              content: "--",
                              position: (466, 47),
                             },
                             Expression {
                              expression: Variable {
                               identifier: "flag",
                               position: (466, 51),
                              },
                             },
                            ],
                           },
                          ],
                         },
                         position: (466, 25),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "cfgFlags",
                           position: (467, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "concatMapStringsSep",
                          position: (467, 24),
                         },
                         arguments: [
                          String {
                           parts: [
                            Raw {
                             content: " ",
                             position: (467, 45),
                            },
                           ],
                          },
                          Variable {
                           identifier: "mkCfgFlag",
                           position: (467, 48),
                          },
                          PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (467, 58),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "config",
                              position: (467, 62),
                             },
                            ],
                           },
                           default: None,
                          },
                         ],
                        },
                       ),
                      ],
                      target: String {
                       parts: [
                        Raw {
                         content: "@",
                         position: (468, 15),
                        },
                        Expression {
                         expression: Variable {
                          identifier: "taskd",
                          position: (468, 18),
                         },
                        },
                        Raw {
                         content: " taskd server ",
                         position: (468, 24),
                        },
                        Expression {
                         expression: Variable {
                          identifier: "cfgFlags",
                          position: (468, 40),
                         },
                        },
                       ],
                      },
                      position: (465, 23),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "ExecReload",
                        position: (469, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "pkgs",
                          position: (469, 27),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "coreutils",
                            position: (469, 32),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/bin/kill -USR1 $MAINPID",
                        position: (469, 42),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "Restart",
                        position: (470, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "on-failure",
                        position: (470, 22),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "PermissionsStartOnly",
                        position: (471, 11),
                       },
                      ],
                     },
                     Variable {
                      identifier: "true",
                      position: (471, 34),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "PrivateTmp",
                        position: (472, 11),
                       },
                      ],
                     },
                     Variable {
                      identifier: "true",
                      position: (472, 24),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "PrivateDevices",
                        position: (473, 11),
                       },
                      ],
                     },
                     Variable {
                      identifier: "true",
                      position: (473, 28),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "User",
                        position: (474, 11),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (474, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "user",
                         position: (474, 22),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "Group",
                        position: (475, 11),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (475, 19),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "group",
                         position: (475, 23),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                   ],
                   recursive: false,
                   position: (464, 25),
                  },
                 ),
                ],
                recursive: false,
                position: (450, 37),
               },
              ),
             ],
             recursive: false,
             position: (369, 22),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkIf",
            position: (479, 6),
           },
           arguments: [
            BinaryOperation {
             operator: LogicalAnd,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (479, 12),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "enable",
                  position: (479, 16),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "needToCreateCA",
               position: (479, 26),
              },
             ],
             position: (479, 23),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "systemd",
                  position: (480, 7),
                 },
                 Raw {
                  content: "services",
                  position: (480, 15),
                 },
                 Raw {
                  content: "taskserver-ca",
                  position: (480, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "wantedBy",
                     position: (481, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "taskserver.service",
                       position: (481, 23),
                      },
                     ],
                    },
                   ],
                   position: (481, 20),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "after",
                     position: (482, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "taskserver-init.service",
                       position: (482, 20),
                      },
                     ],
                    },
                   ],
                   position: (482, 17),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "before",
                     position: (483, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "taskserver.service",
                       position: (483, 21),
                      },
                     ],
                    },
                   ],
                   position: (483, 18),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (484, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Initialize CA for TaskServer",
                     position: (484, 24),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "serviceConfig",
                     position: (485, 9),
                    },
                    Raw {
                     content: "Type",
                     position: (485, 23),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "oneshot",
                     position: (485, 31),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "serviceConfig",
                     position: (486, 9),
                    },
                    Raw {
                     content: "UMask",
                     position: (486, 23),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "0077",
                     position: (486, 32),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "serviceConfig",
                     position: (487, 9),
                    },
                    Raw {
                     content: "PrivateNetwork",
                     position: (487, 23),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (487, 40),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "serviceConfig",
                     position: (488, 9),
                    },
                    Raw {
                     content: "PrivateTmp",
                     position: (488, 23),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (488, 36),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "script",
                     position: (490, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "silent_certtool() {\n  if ! output=\"$(\"",
                     position: (491, 1),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "certtool",
                      position: (492, 31),
                     },
                    },
                    Raw {
                     content: "\" \"$@\" 2>&1)\"; then\n    echo \"GNUTLS certtool invocation failed with output:\" >&2\n    echo \"$output\" >&2\n  fi\n}\n\nmkdir -m 0700 -p \"",
                     position: (492, 40),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (498, 31),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (498, 35),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys\"\nchown root:root \"",
                     position: (498, 43),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (499, 30),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (499, 34),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys\"\n\nif [ ! -e \"",
                     position: (499, 42),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (501, 24),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (501, 28),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys/ca.key\" ]; then\n  silent_certtool -p \\\n    --bits ",
                     position: (501, 36),
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "toString",
                       position: (503, 24),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (503, 33),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "pki",
                           position: (503, 37),
                          },
                          Raw {
                           content: "auto",
                           position: (503, 41),
                          },
                          Raw {
                           content: "bits",
                           position: (503, 46),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    },
                    Raw {
                     content: " \\\n    --outfile \"",
                     position: (503, 51),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (504, 28),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (504, 32),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys/ca.key\"\n  silent_certtool -s \\\n    --template \"",
                     position: (504, 40),
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (506, 29),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "writeText",
                          position: (506, 34),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "taskserver-ca.template",
                          position: (506, 45),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "cn = ",
                          position: (507, 1),
                         },
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (507, 24),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "fqdn",
                              position: (507, 28),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: "\nexpiration_days = ",
                          position: (507, 33),
                         },
                         Expression {
                          expression: FunctionApplication {
                           function: Variable {
                            identifier: "toString",
                            position: (508, 37),
                           },
                           arguments: [
                            PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (508, 46),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "pki",
                                position: (508, 50),
                               },
                               Raw {
                                content: "auto",
                                position: (508, 54),
                               },
                               Raw {
                                content: "expiration",
                                position: (508, 59),
                               },
                               Raw {
                                content: "ca",
                                position: (508, 70),
                               },
                              ],
                             },
                             default: None,
                            },
                           ],
                          },
                         },
                         Raw {
                          content: "\ncert_signing_key\nca\n",
                          position: (508, 73),
                         },
                        ],
                       },
                      ],
                     },
                    },
                    Raw {
                     content: "\" \\\n    --load-privkey \"",
                     position: (511, 18),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (512, 33),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (512, 37),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys/ca.key\" \\\n    --outfile \"",
                     position: (512, 45),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (513, 28),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (513, 32),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys/ca.cert\"\n\n  chgrp \"",
                     position: (513, 40),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (515, 22),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "group",
                         position: (515, 26),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "\" \"",
                     position: (515, 32),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (515, 37),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (515, 41),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys/ca.cert\"\n  chmod g+r \"",
                     position: (515, 49),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (516, 26),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (516, 30),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys/ca.cert\"\nfi\n\nif [ ! -e \"",
                     position: (516, 38),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (519, 24),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (519, 28),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys/server.key\" ]; then\n  silent_certtool -p \\\n    --bits ",
                     position: (519, 36),
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "toString",
                       position: (521, 24),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (521, 33),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "pki",
                           position: (521, 37),
                          },
                          Raw {
                           content: "auto",
                           position: (521, 41),
                          },
                          Raw {
                           content: "bits",
                           position: (521, 46),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    },
                    Raw {
                     content: " \\\n    --outfile \"",
                     position: (521, 51),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (522, 28),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (522, 32),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys/server.key\"\n\n  silent_certtool -c \\\n    --template \"",
                     position: (522, 40),
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (525, 29),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "writeText",
                          position: (525, 34),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "taskserver-cert.template",
                          position: (525, 45),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "cn = ",
                          position: (526, 1),
                         },
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (526, 24),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "fqdn",
                              position: (526, 28),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: "\nexpiration_days = ",
                          position: (526, 33),
                         },
                         Expression {
                          expression: FunctionApplication {
                           function: Variable {
                            identifier: "toString",
                            position: (527, 37),
                           },
                           arguments: [
                            PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (527, 46),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "pki",
                                position: (527, 50),
                               },
                               Raw {
                                content: "auto",
                                position: (527, 54),
                               },
                               Raw {
                                content: "expiration",
                                position: (527, 59),
                               },
                               Raw {
                                content: "server",
                                position: (527, 70),
                               },
                              ],
                             },
                             default: None,
                            },
                           ],
                          },
                         },
                         Raw {
                          content: "\ntls_www_server\nencryption_key\nsigning_key\n",
                          position: (527, 77),
                         },
                        ],
                       },
                      ],
                     },
                    },
                    Raw {
                     content: "\" \\\n    --load-ca-privkey \"",
                     position: (531, 18),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (532, 36),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (532, 40),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys/ca.key\" \\\n    --load-ca-certificate \"",
                     position: (532, 48),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (533, 40),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (533, 44),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys/ca.cert\" \\\n    --load-privkey \"",
                     position: (533, 52),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (534, 33),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (534, 37),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys/server.key\" \\\n    --outfile \"",
                     position: (534, 45),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (535, 28),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (535, 32),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys/server.cert\"\n\n  chgrp \"",
                     position: (535, 40),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (537, 22),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "group",
                         position: (537, 26),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "\" \\\n    \"",
                     position: (537, 32),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (538, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (538, 22),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys/server.key\" \\\n    \"",
                     position: (538, 30),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (539, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (539, 22),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys/server.cert\"\n\n  chmod g+r \\\n    \"",
                     position: (539, 30),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (542, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (542, 22),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys/server.key\" \\\n    \"",
                     position: (542, 30),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (543, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (543, 22),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys/server.cert\"\nfi\n\nif [ ! -e \"",
                     position: (543, 30),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (546, 24),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (546, 28),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys/server.crl\" ]; then\n  silent_certtool --generate-crl \\\n    --template \"",
                     position: (546, 36),
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (548, 29),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "writeText",
                          position: (548, 34),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "taskserver-crl.template",
                          position: (548, 45),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "expiration_days = ",
                          position: (549, 1),
                         },
                         Expression {
                          expression: FunctionApplication {
                           function: Variable {
                            identifier: "toString",
                            position: (549, 37),
                           },
                           arguments: [
                            PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (549, 46),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "pki",
                                position: (549, 50),
                               },
                               Raw {
                                content: "auto",
                                position: (549, 54),
                               },
                               Raw {
                                content: "expiration",
                                position: (549, 59),
                               },
                               Raw {
                                content: "crl",
                                position: (549, 70),
                               },
                              ],
                             },
                             default: None,
                            },
                           ],
                          },
                         },
                         Raw {
                          content: "\n",
                          position: (549, 74),
                         },
                        ],
                       },
                      ],
                     },
                    },
                    Raw {
                     content: "\" \\\n    --load-ca-privkey \"",
                     position: (550, 18),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (551, 36),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (551, 40),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys/ca.key\" \\\n    --load-ca-certificate \"",
                     position: (551, 48),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (552, 40),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (552, 44),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys/ca.cert\" \\\n    --outfile \"",
                     position: (552, 52),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (553, 28),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (553, 32),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys/server.crl\"\n\n  chgrp \"",
                     position: (553, 40),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (555, 22),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "group",
                         position: (555, 26),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "\" \"",
                     position: (555, 32),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (555, 37),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (555, 41),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys/server.crl\"\n  chmod g+r \"",
                     position: (555, 49),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (556, 26),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (556, 30),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys/server.crl\"\nfi\n\nchmod go+x \"",
                     position: (556, 38),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (559, 25),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (559, 29),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/keys\"\n",
                     position: (559, 37),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (480, 40),
               },
              ),
             ],
             recursive: false,
             position: (479, 42),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkIf",
            position: (563, 6),
           },
           arguments: [
            BinaryOperation {
             operator: LogicalAnd,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (563, 12),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "enable",
                  position: (563, 16),
                 },
                ],
               },
               default: None,
              },
              BinaryOperation {
               operator: NotEqualTo,
               operands: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (563, 26),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "listenHost",
                    position: (563, 30),
                   },
                  ],
                 },
                 default: None,
                },
                String {
                 parts: [
                  Raw {
                   content: "localhost",
                   position: (563, 45),
                  },
                 ],
                },
               ],
               position: (563, 41),
              },
             ],
             position: (563, 23),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "networking",
                  position: (564, 7),
                 },
                 Raw {
                  content: "firewall",
                  position: (564, 18),
                 },
                 Raw {
                  content: "allowedTCPPorts",
                  position: (564, 27),
                 },
                ],
               },
               List {
                elements: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (564, 47),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "listenPort",
                     position: (564, 51),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
                position: (564, 45),
               },
              ),
             ],
             recursive: false,
             position: (563, 57),
            },
           ],
          },
         ],
         position: (368, 20),
        },
       ],
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "meta",
         position: (568, 3),
        },
        Raw {
         content: "doc",
         position: (568, 8),
        },
       ],
      },
      Path {
       parts: [
        Raw {
         content: "./doc.xml",
         position: (568, 14),
        },
       ],
      },
     ),
    ],
    recursive: false,
    position: (135, 4),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}