---
Function {
 argument: Destructured {
  identifier: None,
  arguments: [
   DestructuredArgument {
    identifier: "config",
    default: None,
   },
   DestructuredArgument {
    identifier: "lib",
    default: None,
   },
   DestructuredArgument {
    identifier: "pkgs",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (3, 6),
  },
  target: LetIn {
   bindings: [
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "cfg",
        position: (6, 3),
       },
      ],
     },
     to: PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (6, 9),
      },
      attribute_path: AttributePath {
       parts: [
        Raw {
         content: "services",
         position: (6, 16),
        },
        Raw {
         content: "taskserver",
         position: (6, 25),
        },
       ],
      },
      default: None,
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "taskd",
        position: (8, 3),
       },
      ],
     },
     to: String {
      parts: [
       Interpolation {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (8, 14),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "taskserver",
            position: (8, 19),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "/bin/taskd",
        position: (8, 30),
       },
      ],
      position: (8, 11),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkManualPkiOption",
        position: (10, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "desc",
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "mkOption",
        position: (10, 29),
       },
       arguments: [
        Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "type",
              position: (11, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "types",
              position: (11, 12),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "nullOr",
                position: (11, 18),
               },
              ],
             },
             default: None,
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (11, 25),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "path",
                 position: (11, 31),
                },
               ],
              },
              default: None,
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "default",
              position: (12, 5),
             },
            ],
           },
           to: Variable {
            identifier: "null",
            position: (12, 15),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "description",
              position: (13, 5),
             },
            ],
           },
           to: 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, 26),
             },
            ],
            position: (13, 24),
           },
          },
         ],
         recursive: false,
         position: (10, 38),
        },
       ],
      },
      position: (10, 23),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "manualPkiOptions",
        position: (20, 3),
       },
      ],
     },
     to: Map {
      bindings: [
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "ca",
           position: (21, 5),
          },
          Raw {
           content: "cert",
           position: (21, 8),
          },
         ],
        },
        to: FunctionApplication {
         function: Variable {
          identifier: "mkManualPkiOption",
          position: (21, 15),
         },
         arguments: [
          String {
           parts: [
            Raw {
             content: "Fully qualified path to the CA certificate.\n",
             position: (22, 1),
            },
           ],
           position: (21, 33),
          },
         ],
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "server",
           position: (25, 5),
          },
          Raw {
           content: "cert",
           position: (25, 12),
          },
         ],
        },
        to: FunctionApplication {
         function: Variable {
          identifier: "mkManualPkiOption",
          position: (25, 19),
         },
         arguments: [
          String {
           parts: [
            Raw {
             content: "Fully qualified path to the server certificate.\n",
             position: (26, 1),
            },
           ],
           position: (25, 37),
          },
         ],
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "server",
           position: (29, 5),
          },
          Raw {
           content: "crl",
           position: (29, 12),
          },
         ],
        },
        to: 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),
            },
           ],
           position: (29, 36),
          },
         ],
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "server",
           position: (33, 5),
          },
          Raw {
           content: "key",
           position: (33, 12),
          },
         ],
        },
        to: FunctionApplication {
         function: Variable {
          identifier: "mkManualPkiOption",
          position: (33, 18),
         },
         arguments: [
          String {
           parts: [
            Raw {
             content: "Fully qualified path to the server key.\n",
             position: (34, 1),
            },
           ],
           position: (33, 36),
          },
         ],
        },
       },
      ],
      recursive: false,
      position: (20, 22),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkAutoDesc",
        position: (38, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "preamble",
      },
      definition: String {
       parts: [
        Raw {
         content: "",
         position: (39, 1),
        },
        Interpolation {
         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, 26),
      },
      position: (38, 16),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mkExpireOption",
        position: (47, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "desc",
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "mkOption",
        position: (47, 26),
       },
       arguments: [
        Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "type",
              position: (48, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "types",
              position: (48, 12),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "nullOr",
                position: (48, 18),
               },
              ],
             },
             default: None,
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (48, 25),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "int",
                 position: (48, 31),
                },
               ],
              },
              default: None,
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "default",
              position: (49, 5),
             },
            ],
           },
           to: Variable {
            identifier: "null",
            position: (49, 15),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "example",
              position: (50, 5),
             },
            ],
           },
           to: Int {
            value: 365,
            position: (50, 15),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "apply",
              position: (51, 5),
             },
            ],
           },
           to: Function {
            argument: Simple {
             identifier: "val",
            },
            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),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "description",
              position: (52, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkAutoDesc",
             position: (52, 19),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "The expiration time of ",
                position: (53, 1),
               },
               Interpolation {
                expression: Variable {
                 identifier: "desc",
                 position: (53, 32),
                },
               },
               Raw {
                content: " in days or <literal>null</literal> for no\nexpiration time.\n",
                position: (53, 37),
               },
              ],
              position: (52, 30),
             },
            ],
           },
          },
         ],
         recursive: false,
         position: (47, 35),
        },
       ],
      },
      position: (47, 20),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "autoPkiOptions",
        position: (58, 3),
       },
      ],
     },
     to: Map {
      bindings: [
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "bits",
           position: (59, 5),
          },
         ],
        },
        to: FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (59, 12),
         },
         arguments: [
          Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "type",
                position: (60, 7),
               },
              ],
             },
             to: PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (60, 14),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "int",
                 position: (60, 20),
                },
               ],
              },
              default: None,
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "default",
                position: (61, 7),
               },
              ],
             },
             to: Int {
              value: 4096,
              position: (61, 17),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "example",
                position: (62, 7),
               },
              ],
             },
             to: Int {
              value: 2048,
              position: (62, 17),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "description",
                position: (63, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkAutoDesc",
               position: (63, 21),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "The bit size for generated keys.",
                  position: (63, 33),
                 },
                ],
                position: (63, 32),
               },
              ],
             },
            },
           ],
           recursive: false,
           position: (59, 21),
          },
         ],
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "expiration",
           position: (66, 5),
          },
         ],
        },
        to: Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "ca",
              position: (67, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkExpireOption",
             position: (67, 12),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "the CA certificate",
                position: (67, 28),
               },
              ],
              position: (67, 27),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "server",
              position: (68, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkExpireOption",
             position: (68, 16),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "the server certificate",
                position: (68, 32),
               },
              ],
              position: (68, 31),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "client",
              position: (69, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkExpireOption",
             position: (69, 16),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "client certificates",
                position: (69, 32),
               },
              ],
              position: (69, 31),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "crl",
              position: (70, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkExpireOption",
             position: (70, 13),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "the certificate revocation list (CRL)",
                position: (70, 29),
               },
              ],
              position: (70, 28),
             },
            ],
           },
          },
         ],
         recursive: false,
         position: (66, 18),
        },
       },
      ],
      recursive: false,
      position: (58, 20),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "needToCreateCA",
        position: (74, 3),
       },
      ],
     },
     to: LetIn {
      bindings: [
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "notFound",
           position: (75, 5),
          },
         ],
        },
        to: Function {
         argument: Simple {
          identifier: "path",
         },
         definition: LetIn {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "dotted",
               position: (76, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "concatStringsSep",
              position: (76, 16),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: ".",
                 position: (76, 34),
                },
               ],
               position: (76, 33),
              },
              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),
              },
              Interpolation {
               expression: Variable {
                identifier: "dotted",
                position: (77, 57),
               },
              },
              Raw {
               content: "'.",
               position: (77, 64),
              },
             ],
             position: (77, 14),
            },
           ],
          },
          position: (75, 22),
         },
         position: (75, 16),
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "findPkiDefinitions",
           position: (78, 5),
          },
         ],
        },
        to: Function {
         argument: Simple {
          identifier: "path",
         },
         definition: Function {
          argument: Simple {
           identifier: "attrs",
          },
          definition: LetIn {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "mkSublist",
                position: (79, 7),
               },
              ],
             },
             to: Function {
              argument: Simple {
               identifier: "key",
              },
              definition: Function {
               argument: Simple {
                identifier: "val",
               },
               definition: LetIn {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "newPath",
                     position: (80, 9),
                    },
                   ],
                  },
                  to: 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),
                   },
                   Parentheses {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "notFound",
                      position: (82, 35),
                     },
                     arguments: [
                      Variable {
                       identifier: "newPath",
                       position: (82, 44),
                      },
                     ],
                    },
                    position: (82, 34),
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (82, 53),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      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: [
             Parentheses {
              expression: FunctionApplication {
               function: Variable {
                identifier: "mapAttrsToList",
                position: (84, 17),
               },
               arguments: [
                Variable {
                 identifier: "mkSublist",
                 position: (84, 32),
                },
                Variable {
                 identifier: "attrs",
                 position: (84, 42),
                },
               ],
              },
              position: (84, 16),
             },
            ],
           },
           position: (78, 39),
          },
          position: (78, 32),
         },
         position: (78, 26),
        },
       },
      ],
      target: FunctionApplication {
       function: Variable {
        identifier: "all",
        position: (85, 6),
       },
       arguments: [
        Parentheses {
         expression: Function {
          argument: Simple {
           identifier: "x",
          },
          definition: BinaryOperation {
           operator: EqualTo,
           operands: [
            Variable {
             identifier: "x",
             position: (85, 14),
            },
            Variable {
             identifier: "null",
             position: (85, 19),
            },
           ],
           position: (85, 16),
          },
          position: (85, 11),
         },
         position: (85, 10),
        },
        Parentheses {
         expression: FunctionApplication {
          function: Variable {
           identifier: "findPkiDefinitions",
           position: (85, 26),
          },
          arguments: [
           List {
            elements: [],
            position: (85, 45),
           },
           Variable {
            identifier: "manualPkiOptions",
            position: (85, 48),
           },
          ],
         },
         position: (85, 25),
        },
       ],
      },
      position: (74, 20),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "orgOptions",
        position: (87, 3),
       },
      ],
     },
     to: Function {
      argument: Destructured {
       identifier: None,
       arguments: [],
       ellipsis: true,
      },
      definition: Map {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "options",
            position: (88, 5),
           },
           Raw {
            content: "users",
            position: (88, 13),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (88, 21),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "type",
                 position: (89, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (89, 14),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "uniq",
                   position: (89, 20),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Parentheses {
                 expression: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (89, 26),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "listOf",
                      position: (89, 32),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (89, 39),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "str",
                       position: (89, 45),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                 position: (89, 25),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "default",
                 position: (90, 7),
                },
               ],
              },
              to: List {
               elements: [],
               position: (90, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "example",
                 position: (91, 7),
                },
               ],
              },
              to: List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "alice",
                   position: (91, 20),
                  },
                 ],
                 position: (91, 19),
                },
                String {
                 parts: [
                  Raw {
                   content: "bob",
                   position: (91, 28),
                  },
                 ],
                 position: (91, 27),
                },
               ],
               position: (91, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (92, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "A list of user names that belong to the organization.\n",
                 position: (93, 1),
                },
               ],
               position: (92, 21),
              },
             },
            ],
            recursive: false,
            position: (88, 30),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "options",
            position: (97, 5),
           },
           Raw {
            content: "groups",
            position: (97, 13),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (97, 22),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "type",
                 position: (98, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (98, 14),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "listOf",
                   position: (98, 20),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (98, 27),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "str",
                    position: (98, 33),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "default",
                 position: (99, 7),
                },
               ],
              },
              to: List {
               elements: [],
               position: (99, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "example",
                 position: (100, 7),
                },
               ],
              },
              to: List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "workers",
                   position: (100, 20),
                  },
                 ],
                 position: (100, 19),
                },
                String {
                 parts: [
                  Raw {
                   content: "slackers",
                   position: (100, 30),
                  },
                 ],
                 position: (100, 29),
                },
               ],
               position: (100, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (101, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "A list of group names that belong to the organization.\n",
                 position: (102, 1),
                },
               ],
               position: (101, 21),
              },
             },
            ],
            recursive: false,
            position: (97, 31),
           },
          ],
         },
        },
       ],
       recursive: false,
       position: (87, 25),
      },
      position: (87, 16),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "certtool",
        position: (107, 3),
       },
      ],
     },
     to: String {
      parts: [
       Interpolation {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (107, 17),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "gnutls",
            position: (107, 22),
           },
           Raw {
            content: "bin",
            position: (107, 29),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "/bin/certtool",
        position: (107, 33),
       },
      ],
      position: (107, 14),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "nixos-taskserver",
        position: (109, 3),
       },
      ],
     },
     to: With {
      expression: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (109, 27),
       },
       attribute_path: AttributePath {
        parts: [
         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: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "name",
              position: (110, 5),
             },
            ],
           },
           to: String {
            parts: [
             Raw {
              content: "nixos-taskserver",
              position: (110, 13),
             },
            ],
            position: (110, 12),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "src",
              position: (112, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "pkgs",
              position: (112, 11),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "runCommand",
                position: (112, 16),
               },
              ],
             },
             default: None,
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "nixos-taskserver-src",
                position: (112, 28),
               },
              ],
              position: (112, 27),
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "preferLocalBuild",
                   position: (112, 52),
                  },
                 ],
                },
                to: Variable {
                 identifier: "true",
                 position: (112, 71),
                },
               },
              ],
              recursive: false,
              position: (112, 50),
             },
             String {
              parts: [
               Raw {
                content: "mkdir -p \"$out\"\ncat \"",
                position: (113, 1),
               },
               Interpolation {
                expression: FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (114, 14),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "substituteAll",
                     position: (114, 19),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "src",
                        position: (115, 9),
                       },
                      ],
                     },
                     to: Path {
                      parts: [
                       Raw {
                        content: "./helper-tool.py",
                        position: (115, 15),
                       },
                      ],
                      position: (115, 15),
                     },
                    },
                    Inherit {
                     from: None,
                     attributes: [
                      Raw {
                       content: "taskd",
                       position: (116, 17),
                      },
                      Raw {
                       content: "certtool",
                       position: (116, 23),
                      },
                     ],
                    },
                    Inherit {
                     from: Some(
                      Variable {
                       identifier: "cfg",
                       position: (117, 18),
                      },
                     ),
                     attributes: [
                      Raw {
                       content: "dataDir",
                       position: (117, 23),
                      },
                      Raw {
                       content: "user",
                       position: (117, 31),
                      },
                      Raw {
                       content: "group",
                       position: (117, 36),
                      },
                      Raw {
                       content: "fqdn",
                       position: (117, 42),
                      },
                     ],
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "certBits",
                        position: (118, 9),
                       },
                      ],
                     },
                     to: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (118, 20),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "pki",
                         position: (118, 24),
                        },
                        Raw {
                         content: "auto",
                         position: (118, 28),
                        },
                        Raw {
                         content: "bits",
                         position: (118, 33),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "clientExpiration",
                        position: (119, 9),
                       },
                      ],
                     },
                     to: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (119, 28),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        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,
                     },
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "crlExpiration",
                        position: (120, 9),
                       },
                      ],
                     },
                     to: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (120, 25),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        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,
                     },
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "isAutoConfig",
                        position: (121, 9),
                       },
                      ],
                     },
                     to: IfThenElse {
                      predicate: Variable {
                       identifier: "needToCreateCA",
                       position: (121, 27),
                      },
                      then: String {
                       parts: [
                        Raw {
                         content: "True",
                         position: (121, 48),
                        },
                       ],
                       position: (121, 47),
                      },
                      else_: String {
                       parts: [
                        Raw {
                         content: "False",
                         position: (121, 60),
                        },
                       ],
                       position: (121, 59),
                      },
                      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),
               },
              ],
              position: (112, 79),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "propagatedBuildInputs",
              position: (132, 5),
             },
            ],
           },
           to: List {
            elements: [
             Variable {
              identifier: "click",
              position: (132, 31),
             },
            ],
            position: (132, 29),
           },
          },
         ],
         recursive: false,
         position: (109, 69),
        },
       ],
      },
      position: (109, 22),
     },
    },
   ],
   target: Map {
    bindings: [
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "options",
         position: (136, 3),
        },
       ],
      },
      to: Map {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "services",
            position: (137, 5),
           },
           Raw {
            content: "taskserver",
            position: (137, 14),
           },
          ],
         },
         to: Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "enable",
               position: (138, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (138, 16),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (139, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (139, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "bool",
                     position: (139, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (140, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "false",
                  position: (140, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (141, 9),
                   },
                  ],
                 },
                 to: LetIn {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "url",
                       position: (142, 11),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "https://nixos.org/manual/nixos/stable/index.html#module-services-taskserver",
                       position: (142, 18),
                      },
                     ],
                     position: (142, 17),
                    },
                   },
                  ],
                  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),
                    },
                    Interpolation {
                     expression: Variable {
                      identifier: "url",
                      position: (147, 37),
                     },
                    },
                    Raw {
                     content: "\">in the NixOS manual</link>.\n",
                     position: (147, 41),
                    },
                   ],
                   position: (143, 12),
                  },
                  position: (141, 23),
                 },
                },
               ],
               recursive: false,
               position: (138, 25),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "user",
               position: (151, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (151, 14),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (152, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (152, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "str",
                     position: (152, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (153, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "taskd",
                    position: (153, 20),
                   },
                  ],
                  position: (153, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (154, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "User for Taskserver.",
                    position: (154, 24),
                   },
                  ],
                  position: (154, 23),
                 },
                },
               ],
               recursive: false,
               position: (151, 23),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "group",
               position: (157, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (157, 15),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (158, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (158, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "str",
                     position: (158, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (159, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "taskd",
                    position: (159, 20),
                   },
                  ],
                  position: (159, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (160, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Group for Taskserver.",
                    position: (160, 24),
                   },
                  ],
                  position: (160, 23),
                 },
                },
               ],
               recursive: false,
               position: (157, 24),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "dataDir",
               position: (163, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (163, 17),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (164, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (164, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "path",
                     position: (164, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (165, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "/var/lib/taskserver",
                    position: (165, 20),
                   },
                  ],
                  position: (165, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (166, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Data directory for Taskserver.",
                    position: (166, 24),
                   },
                  ],
                  position: (166, 23),
                 },
                },
               ],
               recursive: false,
               position: (163, 26),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "ciphers",
               position: (169, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (169, 17),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (170, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (170, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "nullOr",
                      position: (170, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Parentheses {
                    expression: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (170, 30),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "separatedString",
                         position: (170, 36),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: ":",
                         position: (170, 53),
                        },
                       ],
                       position: (170, 52),
                      },
                     ],
                    },
                    position: (170, 29),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (171, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "null",
                  position: (171, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (172, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "NORMAL:-VERS-SSL3.0",
                    position: (172, 20),
                   },
                  ],
                  position: (172, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (173, 9),
                   },
                  ],
                 },
                 to: LetIn {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "url",
                       position: (174, 11),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "https://gnutls.org/manual/html_node/Priority-Strings.html",
                       position: (174, 18),
                      },
                     ],
                     position: (174, 17),
                    },
                   },
                  ],
                  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),
                    },
                    Interpolation {
                     expression: Variable {
                      identifier: "url",
                      position: (177, 51),
                     },
                    },
                    Raw {
                     content: "\"/> for full details.\n",
                     position: (177, 55),
                    },
                   ],
                   position: (175, 12),
                  },
                  position: (173, 23),
                 },
                },
               ],
               recursive: false,
               position: (169, 26),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "organisations",
               position: (181, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (181, 23),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (182, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (182, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "attrsOf",
                      position: (182, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Parentheses {
                    expression: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (182, 31),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "submodule",
                         position: (182, 37),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      Variable {
                       identifier: "orgOptions",
                       position: (182, 47),
                      },
                     ],
                    },
                    position: (182, 30),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (183, 9),
                   },
                  ],
                 },
                 to: Map {
                  bindings: [],
                  recursive: false,
                  position: (183, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (184, 9),
                   },
                   Raw {
                    content: "myShinyOrganisation",
                    position: (184, 17),
                   },
                   Raw {
                    content: "users",
                    position: (184, 37),
                   },
                  ],
                 },
                 to: List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "alice",
                      position: (184, 48),
                     },
                    ],
                    position: (184, 47),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "bob",
                      position: (184, 56),
                     },
                    ],
                    position: (184, 55),
                   },
                  ],
                  position: (184, 45),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (185, 9),
                   },
                   Raw {
                    content: "myShinyOrganisation",
                    position: (185, 17),
                   },
                   Raw {
                    content: "groups",
                    position: (185, 37),
                   },
                  ],
                 },
                 to: List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "staff",
                      position: (185, 49),
                     },
                    ],
                    position: (185, 48),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "outsiders",
                      position: (185, 57),
                     },
                    ],
                    position: (185, 56),
                   },
                  ],
                  position: (185, 46),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (186, 9),
                   },
                   Raw {
                    content: "yetAnotherOrganisation",
                    position: (186, 17),
                   },
                   Raw {
                    content: "users",
                    position: (186, 40),
                   },
                  ],
                 },
                 to: List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "foo",
                      position: (186, 51),
                     },
                    ],
                    position: (186, 50),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "bar",
                      position: (186, 57),
                     },
                    ],
                    position: (186, 56),
                   },
                  ],
                  position: (186, 48),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (187, 9),
                   },
                  ],
                 },
                 to: 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),
                   },
                  ],
                  position: (187, 23),
                 },
                },
               ],
               recursive: false,
               position: (181, 32),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "confirmation",
               position: (194, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (194, 22),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (195, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (195, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "bool",
                     position: (195, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (196, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "true",
                  position: (196, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (197, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Determines whether certain commands are confirmed.\n",
                    position: (198, 1),
                   },
                  ],
                  position: (197, 23),
                 },
                },
               ],
               recursive: false,
               position: (194, 31),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "debug",
               position: (202, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (202, 15),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (203, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (203, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "bool",
                     position: (203, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (204, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "false",
                  position: (204, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (205, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Logs debugging information.\n",
                    position: (206, 1),
                   },
                  ],
                  position: (205, 23),
                 },
                },
               ],
               recursive: false,
               position: (202, 24),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "extensions",
               position: (210, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (210, 20),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (211, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (211, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "nullOr",
                      position: (211, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (211, 29),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "path",
                       position: (211, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (212, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "null",
                  position: (212, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (213, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Fully qualified path of the Taskserver extension scripts.\nCurrently there are none.\n",
                    position: (214, 1),
                   },
                  ],
                  position: (213, 23),
                 },
                },
               ],
               recursive: false,
               position: (210, 29),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "ipLog",
               position: (219, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (219, 15),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (220, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (220, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "bool",
                     position: (220, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (221, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "false",
                  position: (221, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (222, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Logs the IP addresses of incoming requests.\n",
                    position: (223, 1),
                   },
                  ],
                  position: (222, 23),
                 },
                },
               ],
               recursive: false,
               position: (219, 24),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "queueSize",
               position: (227, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (227, 19),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (228, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (228, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "int",
                     position: (228, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (229, 9),
                   },
                  ],
                 },
                 to: Int {
                  value: 10,
                  position: (229, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (230, 9),
                   },
                  ],
                 },
                 to: 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),
                   },
                  ],
                  position: (230, 23),
                 },
                },
               ],
               recursive: false,
               position: (227, 28),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "requestLimit",
               position: (238, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (238, 22),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (239, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (239, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "int",
                     position: (239, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (240, 9),
                   },
                  ],
                 },
                 to: Int {
                  value: 1048576,
                  position: (240, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (241, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Size limit of incoming requests, in bytes.\n",
                    position: (242, 1),
                   },
                  ],
                  position: (241, 23),
                 },
                },
               ],
               recursive: false,
               position: (238, 31),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "allowedClientIDs",
               position: (246, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (246, 26),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (247, 9),
                   },
                  ],
                 },
                 to: With {
                  expression: Variable {
                   identifier: "types",
                   position: (247, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "either",
                    position: (247, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "str",
                     position: (247, 35),
                    },
                    Parentheses {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "listOf",
                       position: (247, 40),
                      },
                      arguments: [
                       Variable {
                        identifier: "str",
                        position: (247, 47),
                       },
                      ],
                     },
                     position: (247, 39),
                    },
                   ],
                  },
                  position: (247, 16),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (248, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [],
                  position: (248, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (249, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "[Tt]ask [2-9]+",
                      position: (249, 22),
                     },
                    ],
                    position: (249, 21),
                   },
                  ],
                  position: (249, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (250, 9),
                   },
                  ],
                 },
                 to: 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),
                   },
                  ],
                  position: (250, 23),
                 },
                },
               ],
               recursive: false,
               position: (246, 35),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "disallowedClientIDs",
               position: (260, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (260, 29),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (261, 9),
                   },
                  ],
                 },
                 to: With {
                  expression: Variable {
                   identifier: "types",
                   position: (261, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "either",
                    position: (261, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "str",
                     position: (261, 35),
                    },
                    Parentheses {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "listOf",
                       position: (261, 40),
                      },
                      arguments: [
                       Variable {
                        identifier: "str",
                        position: (261, 47),
                       },
                      ],
                     },
                     position: (261, 39),
                    },
                   ],
                  },
                  position: (261, 16),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (262, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [],
                  position: (262, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (263, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "[Tt]ask [2-9]+",
                      position: (263, 22),
                     },
                    ],
                    position: (263, 21),
                   },
                  ],
                  position: (263, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (264, 9),
                   },
                  ],
                 },
                 to: 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),
                   },
                  ],
                  position: (264, 23),
                 },
                },
               ],
               recursive: false,
               position: (260, 38),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "listenHost",
               position: (274, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (274, 20),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (275, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (275, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "str",
                     position: (275, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (276, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "localhost",
                    position: (276, 20),
                   },
                  ],
                  position: (276, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (277, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "::",
                    position: (277, 20),
                   },
                  ],
                  position: (277, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (278, 9),
                   },
                  ],
                 },
                 to: 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),
                   },
                  ],
                  position: (278, 23),
                 },
                },
               ],
               recursive: false,
               position: (274, 29),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "listenPort",
               position: (287, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (287, 20),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (288, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (288, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "int",
                     position: (288, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (289, 9),
                   },
                  ],
                 },
                 to: Int {
                  value: 53589,
                  position: (289, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (290, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Port number of the Taskserver.\n",
                    position: (291, 1),
                   },
                  ],
                  position: (290, 23),
                 },
                },
               ],
               recursive: false,
               position: (287, 29),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "fqdn",
               position: (295, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (295, 14),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (296, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (296, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "str",
                     position: (296, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (297, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "localhost",
                    position: (297, 20),
                   },
                  ],
                  position: (297, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (298, 9),
                   },
                  ],
                 },
                 to: 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),
                   },
                  ],
                  position: (298, 23),
                 },
                },
               ],
               recursive: false,
               position: (295, 23),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "trust",
               position: (304, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (304, 15),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (305, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (305, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "enum",
                      position: (305, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "allow all",
                        position: (305, 30),
                       },
                      ],
                      position: (305, 29),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "strict",
                        position: (305, 42),
                       },
                      ],
                      position: (305, 41),
                     },
                    ],
                    position: (305, 27),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (306, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "strict",
                    position: (306, 20),
                   },
                  ],
                  position: (306, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (307, 9),
                   },
                  ],
                 },
                 to: 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),
                   },
                  ],
                  position: (307, 23),
                 },
                },
               ],
               recursive: false,
               position: (304, 24),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "pki",
               position: (317, 7),
              },
              Raw {
               content: "manual",
               position: (317, 11),
              },
             ],
            },
            to: Variable {
             identifier: "manualPkiOptions",
             position: (317, 20),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "pki",
               position: (318, 7),
              },
              Raw {
               content: "auto",
               position: (318, 11),
              },
             ],
            },
            to: Variable {
             identifier: "autoPkiOptions",
             position: (318, 18),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "config",
               position: (320, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (320, 16),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (321, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (321, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "attrs",
                     position: (321, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (322, 9),
                   },
                   Raw {
                    content: "client",
                    position: (322, 17),
                   },
                   Raw {
                    content: "cert",
                    position: (322, 24),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "/tmp/debugging.cert",
                    position: (322, 32),
                   },
                  ],
                  position: (322, 31),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (323, 9),
                   },
                  ],
                 },
                 to: 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),
                   },
                  ],
                  position: (323, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "apply",
                    position: (340, 9),
                   },
                  ],
                 },
                 to: LetIn {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "mkKey",
                       position: (341, 11),
                      },
                     ],
                    },
                    to: Function {
                     argument: Simple {
                      identifier: "path",
                     },
                     definition: IfThenElse {
                      predicate: BinaryOperation {
                       operator: EqualTo,
                       operands: [
                        Variable {
                         identifier: "path",
                         position: (341, 28),
                        },
                        List {
                         elements: [
                          String {
                           parts: [
                            Raw {
                             content: "server",
                             position: (341, 38),
                            },
                           ],
                           position: (341, 37),
                          },
                          String {
                           parts: [
                            Raw {
                             content: "listen",
                             position: (341, 47),
                            },
                           ],
                           position: (341, 46),
                          },
                         ],
                         position: (341, 36),
                        },
                       ],
                       position: (341, 33),
                      },
                      then: String {
                       parts: [
                        Raw {
                         content: "server",
                         position: (341, 62),
                        },
                       ],
                       position: (341, 61),
                      },
                      else_: FunctionApplication {
                       function: Variable {
                        identifier: "concatStringsSep",
                        position: (342, 30),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: ".",
                           position: (342, 48),
                          },
                         ],
                         position: (342, 47),
                        },
                        Variable {
                         identifier: "path",
                         position: (342, 51),
                        },
                       ],
                      },
                      position: (341, 25),
                     },
                     position: (341, 19),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "recurse",
                       position: (343, 11),
                      },
                     ],
                    },
                    to: Function {
                     argument: Simple {
                      identifier: "path",
                     },
                     definition: Function {
                      argument: Simple {
                       identifier: "attrs",
                      },
                      definition: LetIn {
                       bindings: [
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "mapper",
                            position: (344, 13),
                           },
                          ],
                         },
                         to: Function {
                          argument: Simple {
                           identifier: "name",
                          },
                          definition: Function {
                           argument: Simple {
                            identifier: "val",
                           },
                           definition: LetIn {
                            bindings: [
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "newPath",
                                 position: (345, 15),
                                },
                               ],
                              },
                              to: BinaryOperation {
                               operator: Concatenation,
                               operands: [
                                Variable {
                                 identifier: "path",
                                 position: (345, 25),
                                },
                                List {
                                 elements: [
                                  Variable {
                                   identifier: "name",
                                   position: (345, 35),
                                  },
                                 ],
                                 position: (345, 33),
                                },
                               ],
                               position: (345, 30),
                              },
                             },
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "scalar",
                                 position: (346, 15),
                                },
                               ],
                              },
                              to: 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),
                                 },
                                ],
                                position: (346, 44),
                               },
                               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),
                                  },
                                 ],
                                 position: (347, 50),
                                },
                                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: [
                                 Interpolation {
                                  expression: FunctionApplication {
                                   function: Variable {
                                    identifier: "mkKey",
                                    position: (350, 26),
                                   },
                                   arguments: [
                                    Variable {
                                     identifier: "newPath",
                                     position: (350, 32),
                                    },
                                   ],
                                  },
                                 },
                                 Raw {
                                  content: "=",
                                  position: (350, 40),
                                 },
                                 Interpolation {
                                  expression: Variable {
                                   identifier: "scalar",
                                   position: (350, 43),
                                  },
                                 },
                                ],
                                position: (350, 23),
                               },
                              ],
                              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: [
                         Parentheses {
                          expression: FunctionApplication {
                           function: Variable {
                            identifier: "mapAttrsToList",
                            position: (351, 27),
                           },
                           arguments: [
                            Variable {
                             identifier: "mapper",
                             position: (351, 42),
                            },
                            Variable {
                             identifier: "attrs",
                             position: (351, 49),
                            },
                           ],
                          },
                          position: (351, 26),
                         },
                        ],
                       },
                       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),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "imports",
         position: (357, 3),
        },
       ],
      },
      to: List {
       elements: [
        Parentheses {
         expression: FunctionApplication {
          function: Variable {
           identifier: "mkRemovedOptionModule",
           position: (358, 6),
          },
          arguments: [
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "services",
                position: (358, 30),
               },
              ],
              position: (358, 29),
             },
             String {
              parts: [
               Raw {
                content: "taskserver",
                position: (358, 41),
               },
              ],
              position: (358, 40),
             },
             String {
              parts: [
               Raw {
                content: "extraConfig",
                position: (358, 54),
               },
              ],
              position: (358, 53),
             },
            ],
            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: (358, 68),
           },
          ],
         },
         position: (358, 5),
        },
       ],
       position: (357, 13),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "config",
         position: (368, 3),
        },
       ],
      },
      to: FunctionApplication {
       function: Variable {
        identifier: "mkMerge",
        position: (368, 12),
       },
       arguments: [
        List {
         elements: [
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (369, 6),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (369, 11),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "enable",
                 position: (369, 15),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "environment",
                   position: (370, 7),
                  },
                  Raw {
                   content: "systemPackages",
                   position: (370, 19),
                  },
                 ],
                },
                to: List {
                 elements: [
                  Variable {
                   identifier: "nixos-taskserver",
                   position: (370, 38),
                  },
                 ],
                 position: (370, 36),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "users",
                   position: (372, 7),
                  },
                  Raw {
                   content: "users",
                   position: (372, 13),
                  },
                 ],
                },
                to: FunctionApplication {
                 function: Variable {
                  identifier: "optionalAttrs",
                  position: (372, 21),
                 },
                 arguments: [
                  Parentheses {
                   expression: BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (372, 36),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "user",
                         position: (372, 40),
                        },
                       ],
                      },
                      default: None,
                     },
                     String {
                      parts: [
                       Raw {
                        content: "taskd",
                        position: (372, 49),
                       },
                      ],
                      position: (372, 48),
                     },
                    ],
                    position: (372, 45),
                   },
                   position: (372, 35),
                  },
                  Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "taskd",
                        position: (373, 9),
                       },
                      ],
                     },
                     to: Map {
                      bindings: [
                       Binding {
                        from: AttributePath {
                         parts: [
                          Raw {
                           content: "uid",
                           position: (374, 11),
                          },
                         ],
                        },
                        to: PropertyAccess {
                         expression: Variable {
                          identifier: "config",
                          position: (374, 17),
                         },
                         attribute_path: AttributePath {
                          parts: [
                           Raw {
                            content: "ids",
                            position: (374, 24),
                           },
                           Raw {
                            content: "uids",
                            position: (374, 28),
                           },
                           Raw {
                            content: "taskd",
                            position: (374, 33),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Binding {
                        from: AttributePath {
                         parts: [
                          Raw {
                           content: "description",
                           position: (375, 11),
                          },
                         ],
                        },
                        to: String {
                         parts: [
                          Raw {
                           content: "Taskserver user",
                           position: (375, 26),
                          },
                         ],
                         position: (375, 25),
                        },
                       },
                       Binding {
                        from: AttributePath {
                         parts: [
                          Raw {
                           content: "group",
                           position: (376, 11),
                          },
                         ],
                        },
                        to: PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (376, 19),
                         },
                         attribute_path: AttributePath {
                          parts: [
                           Raw {
                            content: "group",
                            position: (376, 23),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                      ],
                      recursive: false,
                      position: (373, 17),
                     },
                    },
                   ],
                   recursive: false,
                   position: (372, 57),
                  },
                 ],
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "users",
                   position: (380, 7),
                  },
                  Raw {
                   content: "groups",
                   position: (380, 13),
                  },
                 ],
                },
                to: FunctionApplication {
                 function: Variable {
                  identifier: "optionalAttrs",
                  position: (380, 22),
                 },
                 arguments: [
                  Parentheses {
                   expression: BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (380, 37),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "group",
                         position: (380, 41),
                        },
                       ],
                      },
                      default: None,
                     },
                     String {
                      parts: [
                       Raw {
                        content: "taskd",
                        position: (380, 51),
                       },
                      ],
                      position: (380, 50),
                     },
                    ],
                    position: (380, 47),
                   },
                   position: (380, 36),
                  },
                  Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "taskd",
                        position: (381, 9),
                       },
                       Raw {
                        content: "gid",
                        position: (381, 15),
                       },
                      ],
                     },
                     to: PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (381, 21),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        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),
                  },
                 ],
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "services",
                   position: (384, 7),
                  },
                  Raw {
                   content: "taskserver",
                   position: (384, 16),
                  },
                  Raw {
                   content: "config",
                   position: (384, 27),
                  },
                 ],
                },
                to: Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "daemon",
                      position: (386, 9),
                     },
                    ],
                   },
                   to: Variable {
                    identifier: "false",
                    position: (386, 18),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "log",
                      position: (387, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "-",
                      position: (387, 16),
                     },
                    ],
                    position: (387, 15),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "debug",
                      position: (390, 9),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (390, 17),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "debug",
                       position: (390, 21),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "ip",
                      position: (391, 9),
                     },
                     Raw {
                      content: "log",
                      position: (391, 12),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (391, 18),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "ipLog",
                       position: (391, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "ciphers",
                      position: (394, 9),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (394, 19),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "ciphers",
                       position: (394, 23),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "confirmation",
                      position: (395, 9),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (395, 24),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "confirmation",
                       position: (395, 28),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "extensions",
                      position: (396, 9),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (396, 22),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "extensions",
                       position: (396, 26),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "queue",
                      position: (397, 9),
                     },
                     Raw {
                      content: "size",
                      position: (397, 15),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (397, 22),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "queueSize",
                       position: (397, 26),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "request",
                      position: (398, 9),
                     },
                     Raw {
                      content: "limit",
                      position: (398, 17),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (398, 25),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "requestLimit",
                       position: (398, 29),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "client",
                      position: (401, 9),
                     },
                     Raw {
                      content: "allow",
                      position: (401, 16),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (401, 24),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "allowedClientIDs",
                       position: (401, 28),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "client",
                      position: (402, 9),
                     },
                     Raw {
                      content: "deny",
                      position: (402, 16),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (402, 23),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "disallowedClientIDs",
                       position: (402, 27),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "trust",
                      position: (405, 9),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (405, 17),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "trust",
                       position: (405, 21),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "server",
                      position: (406, 9),
                     },
                    ],
                   },
                   to: BinaryOperation {
                    operator: Update,
                    operands: [
                     Map {
                      bindings: [
                       Binding {
                        from: AttributePath {
                         parts: [
                          Raw {
                           content: "listen",
                           position: (407, 11),
                          },
                         ],
                        },
                        to: String {
                         parts: [
                          Interpolation {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (407, 23),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "listenHost",
                               position: (407, 27),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: ":",
                           position: (407, 38),
                          },
                          Interpolation {
                           expression: FunctionApplication {
                            function: Variable {
                             identifier: "toString",
                             position: (407, 41),
                            },
                            arguments: [
                             PropertyAccess {
                              expression: Variable {
                               identifier: "cfg",
                               position: (407, 50),
                              },
                              attribute_path: AttributePath {
                               parts: [
                                Raw {
                                 content: "listenPort",
                                 position: (407, 54),
                                },
                               ],
                              },
                              default: None,
                             },
                            ],
                           },
                          },
                         ],
                         position: (407, 20),
                        },
                       },
                      ],
                      recursive: false,
                      position: (406, 18),
                     },
                     Parentheses {
                      expression: IfThenElse {
                       predicate: Variable {
                        identifier: "needToCreateCA",
                        position: (408, 18),
                       },
                       then: Map {
                        bindings: [
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "cert",
                             position: (409, 11),
                            },
                           ],
                          },
                          to: String {
                           parts: [
                            Interpolation {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "cfg",
                               position: (409, 21),
                              },
                              attribute_path: AttributePath {
                               parts: [
                                Raw {
                                 content: "dataDir",
                                 position: (409, 25),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                            Raw {
                             content: "/keys/server.cert",
                             position: (409, 33),
                            },
                           ],
                           position: (409, 18),
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "key",
                             position: (410, 11),
                            },
                           ],
                          },
                          to: String {
                           parts: [
                            Interpolation {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "cfg",
                               position: (410, 20),
                              },
                              attribute_path: AttributePath {
                               parts: [
                                Raw {
                                 content: "dataDir",
                                 position: (410, 24),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                            Raw {
                             content: "/keys/server.key",
                             position: (410, 32),
                            },
                           ],
                           position: (410, 17),
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "crl",
                             position: (411, 11),
                            },
                           ],
                          },
                          to: String {
                           parts: [
                            Interpolation {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "cfg",
                               position: (411, 20),
                              },
                              attribute_path: AttributePath {
                               parts: [
                                Raw {
                                 content: "dataDir",
                                 position: (411, 24),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                            Raw {
                             content: "/keys/server.crl",
                             position: (411, 32),
                            },
                           ],
                           position: (411, 17),
                          },
                         },
                        ],
                        recursive: false,
                        position: (408, 38),
                       },
                       else_: Map {
                        bindings: [
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "cert",
                             position: (413, 11),
                            },
                           ],
                          },
                          to: String {
                           parts: [
                            Interpolation {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "cfg",
                               position: (413, 21),
                              },
                              attribute_path: AttributePath {
                               parts: [
                                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,
                             },
                            },
                           ],
                           position: (413, 18),
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "key",
                             position: (414, 11),
                            },
                           ],
                          },
                          to: String {
                           parts: [
                            Interpolation {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "cfg",
                               position: (414, 20),
                              },
                              attribute_path: AttributePath {
                               parts: [
                                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,
                             },
                            },
                           ],
                           position: (414, 17),
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Interpolation {
                             expression: FunctionApplication {
                              function: Variable {
                               identifier: "mapNullable",
                               position: (415, 13),
                              },
                              arguments: [
                               Parentheses {
                                expression: Function {
                                 argument: Simple {
                                  identifier: "_",
                                 },
                                 definition: String {
                                  parts: [
                                   Raw {
                                    content: "crl",
                                    position: (415, 30),
                                   },
                                  ],
                                  position: (415, 29),
                                 },
                                 position: (415, 26),
                                },
                                position: (415, 25),
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "cfg",
                                 position: (415, 36),
                                },
                                attribute_path: AttributePath {
                                 parts: [
                                  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,
                               },
                              ],
                             },
                            },
                           ],
                          },
                          to: String {
                           parts: [
                            Interpolation {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "cfg",
                               position: (415, 68),
                              },
                              attribute_path: AttributePath {
                               parts: [
                                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,
                             },
                            },
                           ],
                           position: (415, 65),
                          },
                         },
                        ],
                        recursive: false,
                        position: (412, 16),
                       },
                       position: (408, 15),
                      },
                      position: (408, 14),
                     },
                    ],
                    position: (408, 11),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "ca",
                      position: (418, 9),
                     },
                     Raw {
                      content: "cert",
                      position: (418, 12),
                     },
                    ],
                   },
                   to: IfThenElse {
                    predicate: Variable {
                     identifier: "needToCreateCA",
                     position: (418, 22),
                    },
                    then: String {
                     parts: [
                      Interpolation {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (418, 45),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "dataDir",
                           position: (418, 49),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "/keys/ca.cert",
                       position: (418, 57),
                      },
                     ],
                     position: (418, 42),
                    },
                    else_: String {
                     parts: [
                      Interpolation {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (419, 27),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          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: (419, 24),
                    },
                    position: (418, 19),
                   },
                  },
                 ],
                 recursive: false,
                 position: (384, 36),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "systemd",
                   position: (422, 7),
                  },
                  Raw {
                   content: "services",
                   position: (422, 15),
                  },
                  Raw {
                   content: "taskserver-init",
                   position: (422, 24),
                  },
                 ],
                },
                to: Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "wantedBy",
                      position: (423, 9),
                     },
                    ],
                   },
                   to: List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "taskserver.service",
                        position: (423, 23),
                       },
                      ],
                      position: (423, 22),
                     },
                    ],
                    position: (423, 20),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "before",
                      position: (424, 9),
                     },
                    ],
                   },
                   to: List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "taskserver.service",
                        position: (424, 21),
                       },
                      ],
                      position: (424, 20),
                     },
                    ],
                    position: (424, 18),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "description",
                      position: (425, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "Initialize Taskserver Data Directory",
                      position: (425, 24),
                     },
                    ],
                    position: (425, 23),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "preStart",
                      position: (427, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "mkdir -m 0770 -p \"",
                      position: (428, 1),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (428, 31),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (428, 35),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "\"\nchown \"",
                      position: (428, 43),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (429, 20),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "user",
                          position: (429, 24),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: ":",
                      position: (429, 29),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (429, 32),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "group",
                          position: (429, 36),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "\" \"",
                      position: (429, 42),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (429, 47),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (429, 51),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "\"\n",
                      position: (429, 59),
                     },
                    ],
                    position: (427, 20),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "script",
                      position: (432, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "",
                      position: (433, 1),
                     },
                     Interpolation {
                      expression: Variable {
                       identifier: "taskd",
                       position: (433, 13),
                      },
                     },
                     Raw {
                      content: " init\ntouch \"",
                      position: (433, 19),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (434, 20),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (434, 24),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/.is_initialized\"\n",
                      position: (434, 32),
                     },
                    ],
                    position: (432, 18),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "environment",
                      position: (437, 9),
                     },
                     Raw {
                      content: "TASKDDATA",
                      position: (437, 21),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (437, 33),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "dataDir",
                       position: (437, 37),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "unitConfig",
                      position: (439, 9),
                     },
                     Raw {
                      content: "ConditionPathExists",
                      position: (439, 20),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "!",
                      position: (439, 43),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (439, 46),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (439, 50),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/.is_initialized",
                      position: (439, 58),
                     },
                    ],
                    position: (439, 42),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "serviceConfig",
                      position: (441, 9),
                     },
                     Raw {
                      content: "Type",
                      position: (441, 23),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "oneshot",
                      position: (441, 31),
                     },
                    ],
                    position: (441, 30),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "serviceConfig",
                      position: (442, 9),
                     },
                     Raw {
                      content: "User",
                      position: (442, 23),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (442, 30),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "user",
                       position: (442, 34),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "serviceConfig",
                      position: (443, 9),
                     },
                     Raw {
                      content: "Group",
                      position: (443, 23),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (443, 31),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "group",
                       position: (443, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "serviceConfig",
                      position: (444, 9),
                     },
                     Raw {
                      content: "PermissionsStartOnly",
                      position: (444, 23),
                     },
                    ],
                   },
                   to: Variable {
                    identifier: "true",
                    position: (444, 46),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "serviceConfig",
                      position: (445, 9),
                     },
                     Raw {
                      content: "PrivateNetwork",
                      position: (445, 23),
                     },
                    ],
                   },
                   to: Variable {
                    identifier: "true",
                    position: (445, 40),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "serviceConfig",
                      position: (446, 9),
                     },
                     Raw {
                      content: "PrivateDevices",
                      position: (446, 23),
                     },
                    ],
                   },
                   to: Variable {
                    identifier: "true",
                    position: (446, 40),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "serviceConfig",
                      position: (447, 9),
                     },
                     Raw {
                      content: "PrivateTmp",
                      position: (447, 23),
                     },
                    ],
                   },
                   to: Variable {
                    identifier: "true",
                    position: (447, 36),
                   },
                  },
                 ],
                 recursive: false,
                 position: (422, 42),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "systemd",
                   position: (450, 7),
                  },
                  Raw {
                   content: "services",
                   position: (450, 15),
                  },
                  Raw {
                   content: "taskserver",
                   position: (450, 24),
                  },
                 ],
                },
                to: Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "description",
                      position: (451, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "Taskwarrior Server",
                      position: (451, 24),
                     },
                    ],
                    position: (451, 23),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "wantedBy",
                      position: (453, 9),
                     },
                    ],
                   },
                   to: List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "multi-user.target",
                        position: (453, 23),
                       },
                      ],
                      position: (453, 22),
                     },
                    ],
                    position: (453, 20),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "after",
                      position: (454, 9),
                     },
                    ],
                   },
                   to: List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "network.target",
                        position: (454, 20),
                       },
                      ],
                      position: (454, 19),
                     },
                    ],
                    position: (454, 17),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "environment",
                      position: (456, 9),
                     },
                     Raw {
                      content: "TASKDDATA",
                      position: (456, 21),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (456, 33),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "dataDir",
                       position: (456, 37),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "preStart",
                      position: (458, 9),
                     },
                    ],
                   },
                   to: LetIn {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "jsonOrgs",
                         position: (459, 11),
                        },
                       ],
                      },
                      to: FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "builtins",
                         position: (459, 22),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "toJSON",
                           position: (459, 31),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (459, 38),
                         },
                         attribute_path: AttributePath {
                          parts: [
                           Raw {
                            content: "organisations",
                            position: (459, 42),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "jsonFile",
                         position: (460, 11),
                        },
                       ],
                      },
                      to: FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "pkgs",
                         position: (460, 22),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "writeText",
                           position: (460, 27),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "orgs.json",
                           position: (460, 38),
                          },
                         ],
                         position: (460, 37),
                        },
                        Variable {
                         identifier: "jsonOrgs",
                         position: (460, 49),
                        },
                       ],
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "helperTool",
                         position: (461, 11),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Interpolation {
                         expression: Variable {
                          identifier: "nixos-taskserver",
                          position: (461, 27),
                         },
                        },
                        Raw {
                         content: "/bin/nixos-taskserver",
                         position: (461, 44),
                        },
                       ],
                       position: (461, 24),
                      },
                     },
                    ],
                    target: String {
                     parts: [
                      Interpolation {
                       expression: Variable {
                        identifier: "helperTool",
                        position: (462, 15),
                       },
                      },
                      Raw {
                       content: " process-json '",
                       position: (462, 26),
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "jsonFile",
                        position: (462, 43),
                       },
                      },
                      Raw {
                       content: "'",
                       position: (462, 52),
                      },
                     ],
                     position: (462, 12),
                    },
                    position: (458, 20),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "serviceConfig",
                      position: (464, 9),
                     },
                    ],
                   },
                   to: Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "ExecStart",
                         position: (465, 11),
                        },
                       ],
                      },
                      to: LetIn {
                       bindings: [
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "mkCfgFlag",
                            position: (466, 13),
                           },
                          ],
                         },
                         to: Function {
                          argument: Simple {
                           identifier: "flag",
                          },
                          definition: FunctionApplication {
                           function: Variable {
                            identifier: "escapeShellArg",
                            position: (466, 31),
                           },
                           arguments: [
                            String {
                             parts: [
                              Raw {
                               content: "--",
                               position: (466, 47),
                              },
                              Interpolation {
                               expression: Variable {
                                identifier: "flag",
                                position: (466, 51),
                               },
                              },
                             ],
                             position: (466, 46),
                            },
                           ],
                          },
                          position: (466, 25),
                         },
                        },
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "cfgFlags",
                            position: (467, 13),
                           },
                          ],
                         },
                         to: FunctionApplication {
                          function: Variable {
                           identifier: "concatMapStringsSep",
                           position: (467, 24),
                          },
                          arguments: [
                           String {
                            parts: [
                             Raw {
                              content: " ",
                              position: (467, 45),
                             },
                            ],
                            position: (467, 44),
                           },
                           Variable {
                            identifier: "mkCfgFlag",
                            position: (467, 48),
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (467, 58),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "config",
                               position: (467, 62),
                              },
                             ],
                            },
                            default: None,
                           },
                          ],
                         },
                        },
                       ],
                       target: String {
                        parts: [
                         Raw {
                          content: "@",
                          position: (468, 15),
                         },
                         Interpolation {
                          expression: Variable {
                           identifier: "taskd",
                           position: (468, 18),
                          },
                         },
                         Raw {
                          content: " taskd server ",
                          position: (468, 24),
                         },
                         Interpolation {
                          expression: Variable {
                           identifier: "cfgFlags",
                           position: (468, 40),
                          },
                         },
                        ],
                        position: (468, 14),
                       },
                       position: (465, 23),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "ExecReload",
                         position: (469, 11),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Interpolation {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (469, 27),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "coreutils",
                             position: (469, 32),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/bin/kill -USR1 $MAINPID",
                         position: (469, 42),
                        },
                       ],
                       position: (469, 24),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "Restart",
                         position: (470, 11),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "on-failure",
                         position: (470, 22),
                        },
                       ],
                       position: (470, 21),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "PermissionsStartOnly",
                         position: (471, 11),
                        },
                       ],
                      },
                      to: Variable {
                       identifier: "true",
                       position: (471, 34),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "PrivateTmp",
                         position: (472, 11),
                        },
                       ],
                      },
                      to: Variable {
                       identifier: "true",
                       position: (472, 24),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "PrivateDevices",
                         position: (473, 11),
                        },
                       ],
                      },
                      to: Variable {
                       identifier: "true",
                       position: (473, 28),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "User",
                         position: (474, 11),
                        },
                       ],
                      },
                      to: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (474, 18),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "user",
                          position: (474, 22),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "Group",
                         position: (475, 11),
                        },
                       ],
                      },
                      to: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (475, 19),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "group",
                          position: (475, 23),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                    ],
                    recursive: false,
                    position: (464, 25),
                   },
                  },
                 ],
                 recursive: false,
                 position: (450, 37),
                },
               },
              ],
              recursive: false,
              position: (369, 22),
             },
            ],
           },
           position: (369, 5),
          },
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (479, 6),
            },
            arguments: [
             Parentheses {
              expression: BinaryOperation {
               operator: LogicalAnd,
               operands: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (479, 12),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "enable",
                    position: (479, 16),
                   },
                  ],
                 },
                 default: None,
                },
                Variable {
                 identifier: "needToCreateCA",
                 position: (479, 26),
                },
               ],
               position: (479, 23),
              },
              position: (479, 11),
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "systemd",
                   position: (480, 7),
                  },
                  Raw {
                   content: "services",
                   position: (480, 15),
                  },
                  Raw {
                   content: "taskserver-ca",
                   position: (480, 24),
                  },
                 ],
                },
                to: Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "wantedBy",
                      position: (481, 9),
                     },
                    ],
                   },
                   to: List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "taskserver.service",
                        position: (481, 23),
                       },
                      ],
                      position: (481, 22),
                     },
                    ],
                    position: (481, 20),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "after",
                      position: (482, 9),
                     },
                    ],
                   },
                   to: List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "taskserver-init.service",
                        position: (482, 20),
                       },
                      ],
                      position: (482, 19),
                     },
                    ],
                    position: (482, 17),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "before",
                      position: (483, 9),
                     },
                    ],
                   },
                   to: List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "taskserver.service",
                        position: (483, 21),
                       },
                      ],
                      position: (483, 20),
                     },
                    ],
                    position: (483, 18),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "description",
                      position: (484, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "Initialize CA for TaskServer",
                      position: (484, 24),
                     },
                    ],
                    position: (484, 23),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "serviceConfig",
                      position: (485, 9),
                     },
                     Raw {
                      content: "Type",
                      position: (485, 23),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "oneshot",
                      position: (485, 31),
                     },
                    ],
                    position: (485, 30),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "serviceConfig",
                      position: (486, 9),
                     },
                     Raw {
                      content: "UMask",
                      position: (486, 23),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "0077",
                      position: (486, 32),
                     },
                    ],
                    position: (486, 31),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "serviceConfig",
                      position: (487, 9),
                     },
                     Raw {
                      content: "PrivateNetwork",
                      position: (487, 23),
                     },
                    ],
                   },
                   to: Variable {
                    identifier: "true",
                    position: (487, 40),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "serviceConfig",
                      position: (488, 9),
                     },
                     Raw {
                      content: "PrivateTmp",
                      position: (488, 23),
                     },
                    ],
                   },
                   to: Variable {
                    identifier: "true",
                    position: (488, 36),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "script",
                      position: (490, 9),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Raw {
                      content: "silent_certtool() {\n  if ! output=\"$(\"",
                      position: (491, 1),
                     },
                     Interpolation {
                      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),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (498, 31),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (498, 35),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys\"\nchown root:root \"",
                      position: (498, 43),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (499, 30),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (499, 34),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys\"\n\nif [ ! -e \"",
                      position: (499, 42),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (501, 24),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (501, 28),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys/ca.key\" ]; then\n  silent_certtool -p \\\n    --bits ",
                      position: (501, 36),
                     },
                     Interpolation {
                      expression: FunctionApplication {
                       function: Variable {
                        identifier: "toString",
                        position: (503, 24),
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (503, 33),
                         },
                         attribute_path: AttributePath {
                          parts: [
                           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),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (504, 28),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (504, 32),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys/ca.key\"\n  silent_certtool -s \\\n    --template \"",
                      position: (504, 40),
                     },
                     Interpolation {
                      expression: FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "pkgs",
                         position: (506, 29),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "writeText",
                           position: (506, 34),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "taskserver-ca.template",
                           position: (506, 45),
                          },
                         ],
                         position: (506, 44),
                        },
                        String {
                         parts: [
                          Raw {
                           content: "cn = ",
                           position: (507, 1),
                          },
                          Interpolation {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (507, 24),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "fqdn",
                               position: (507, 28),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "\nexpiration_days = ",
                           position: (507, 33),
                          },
                          Interpolation {
                           expression: FunctionApplication {
                            function: Variable {
                             identifier: "toString",
                             position: (508, 37),
                            },
                            arguments: [
                             PropertyAccess {
                              expression: Variable {
                               identifier: "cfg",
                               position: (508, 46),
                              },
                              attribute_path: AttributePath {
                               parts: [
                                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),
                          },
                         ],
                         position: (506, 69),
                        },
                       ],
                      },
                     },
                     Raw {
                      content: "\" \\\n    --load-privkey \"",
                      position: (511, 18),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (512, 33),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (512, 37),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys/ca.key\" \\\n    --outfile \"",
                      position: (512, 45),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (513, 28),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (513, 32),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys/ca.cert\"\n\n  chgrp \"",
                      position: (513, 40),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (515, 22),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "group",
                          position: (515, 26),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "\" \"",
                      position: (515, 32),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (515, 37),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (515, 41),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys/ca.cert\"\n  chmod g+r \"",
                      position: (515, 49),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (516, 26),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (516, 30),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys/ca.cert\"\nfi\n\nif [ ! -e \"",
                      position: (516, 38),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (519, 24),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (519, 28),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys/server.key\" ]; then\n  silent_certtool -p \\\n    --bits ",
                      position: (519, 36),
                     },
                     Interpolation {
                      expression: FunctionApplication {
                       function: Variable {
                        identifier: "toString",
                        position: (521, 24),
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (521, 33),
                         },
                         attribute_path: AttributePath {
                          parts: [
                           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),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (522, 28),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (522, 32),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys/server.key\"\n\n  silent_certtool -c \\\n    --template \"",
                      position: (522, 40),
                     },
                     Interpolation {
                      expression: FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "pkgs",
                         position: (525, 29),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "writeText",
                           position: (525, 34),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "taskserver-cert.template",
                           position: (525, 45),
                          },
                         ],
                         position: (525, 44),
                        },
                        String {
                         parts: [
                          Raw {
                           content: "cn = ",
                           position: (526, 1),
                          },
                          Interpolation {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (526, 24),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "fqdn",
                               position: (526, 28),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "\nexpiration_days = ",
                           position: (526, 33),
                          },
                          Interpolation {
                           expression: FunctionApplication {
                            function: Variable {
                             identifier: "toString",
                             position: (527, 37),
                            },
                            arguments: [
                             PropertyAccess {
                              expression: Variable {
                               identifier: "cfg",
                               position: (527, 46),
                              },
                              attribute_path: AttributePath {
                               parts: [
                                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),
                          },
                         ],
                         position: (525, 71),
                        },
                       ],
                      },
                     },
                     Raw {
                      content: "\" \\\n    --load-ca-privkey \"",
                      position: (531, 18),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (532, 36),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (532, 40),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys/ca.key\" \\\n    --load-ca-certificate \"",
                      position: (532, 48),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (533, 40),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (533, 44),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys/ca.cert\" \\\n    --load-privkey \"",
                      position: (533, 52),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (534, 33),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (534, 37),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys/server.key\" \\\n    --outfile \"",
                      position: (534, 45),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (535, 28),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (535, 32),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys/server.cert\"\n\n  chgrp \"",
                      position: (535, 40),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (537, 22),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "group",
                          position: (537, 26),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "\" \\\n    \"",
                      position: (537, 32),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (538, 18),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (538, 22),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys/server.key\" \\\n    \"",
                      position: (538, 30),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (539, 18),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (539, 22),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys/server.cert\"\n\n  chmod g+r \\\n    \"",
                      position: (539, 30),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (542, 18),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (542, 22),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys/server.key\" \\\n    \"",
                      position: (542, 30),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (543, 18),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (543, 22),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys/server.cert\"\nfi\n\nif [ ! -e \"",
                      position: (543, 30),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (546, 24),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (546, 28),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys/server.crl\" ]; then\n  silent_certtool --generate-crl \\\n    --template \"",
                      position: (546, 36),
                     },
                     Interpolation {
                      expression: FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "pkgs",
                         position: (548, 29),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "writeText",
                           position: (548, 34),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "taskserver-crl.template",
                           position: (548, 45),
                          },
                         ],
                         position: (548, 44),
                        },
                        String {
                         parts: [
                          Raw {
                           content: "expiration_days = ",
                           position: (549, 1),
                          },
                          Interpolation {
                           expression: FunctionApplication {
                            function: Variable {
                             identifier: "toString",
                             position: (549, 37),
                            },
                            arguments: [
                             PropertyAccess {
                              expression: Variable {
                               identifier: "cfg",
                               position: (549, 46),
                              },
                              attribute_path: AttributePath {
                               parts: [
                                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),
                          },
                         ],
                         position: (548, 70),
                        },
                       ],
                      },
                     },
                     Raw {
                      content: "\" \\\n    --load-ca-privkey \"",
                      position: (550, 18),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (551, 36),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (551, 40),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys/ca.key\" \\\n    --load-ca-certificate \"",
                      position: (551, 48),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (552, 40),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (552, 44),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys/ca.cert\" \\\n    --outfile \"",
                      position: (552, 52),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (553, 28),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (553, 32),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys/server.crl\"\n\n  chgrp \"",
                      position: (553, 40),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (555, 22),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "group",
                          position: (555, 26),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "\" \"",
                      position: (555, 32),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (555, 37),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (555, 41),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys/server.crl\"\n  chmod g+r \"",
                      position: (555, 49),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (556, 26),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (556, 30),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys/server.crl\"\nfi\n\nchmod go+x \"",
                      position: (556, 38),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (559, 25),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "dataDir",
                          position: (559, 29),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/keys\"\n",
                      position: (559, 37),
                     },
                    ],
                    position: (490, 18),
                   },
                  },
                 ],
                 recursive: false,
                 position: (480, 40),
                },
               },
              ],
              recursive: false,
              position: (479, 42),
             },
            ],
           },
           position: (479, 5),
          },
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (563, 6),
            },
            arguments: [
             Parentheses {
              expression: BinaryOperation {
               operator: LogicalAnd,
               operands: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (563, 12),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "enable",
                    position: (563, 16),
                   },
                  ],
                 },
                 default: None,
                },
                BinaryOperation {
                 operator: NotEqualTo,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (563, 26),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "listenHost",
                      position: (563, 30),
                     },
                    ],
                   },
                   default: None,
                  },
                  String {
                   parts: [
                    Raw {
                     content: "localhost",
                     position: (563, 45),
                    },
                   ],
                   position: (563, 44),
                  },
                 ],
                 position: (563, 41),
                },
               ],
               position: (563, 23),
              },
              position: (563, 11),
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "networking",
                   position: (564, 7),
                  },
                  Raw {
                   content: "firewall",
                   position: (564, 18),
                  },
                  Raw {
                   content: "allowedTCPPorts",
                   position: (564, 27),
                  },
                 ],
                },
                to: List {
                 elements: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (564, 47),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "listenPort",
                      position: (564, 51),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (564, 45),
                },
               },
              ],
              recursive: false,
              position: (563, 57),
             },
            ],
           },
           position: (563, 5),
          },
         ],
         position: (368, 20),
        },
       ],
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "meta",
         position: (568, 3),
        },
        Raw {
         content: "doc",
         position: (568, 8),
        },
       ],
      },
      to: Path {
       parts: [
        Raw {
         content: "./doc.xml",
         position: (568, 14),
        },
       ],
       position: (568, 14),
      },
     },
    ],
    recursive: false,
    position: (135, 4),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}