---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (3, 6),
  },
  target: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cfg",
        position: (6, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (6, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (6, 16),
        },
        Raw {
         content: "sympa",
         position: (6, 25),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "dataDir",
        position: (7, 3),
       },
      ],
     },
     String {
      parts: [
       Raw {
        content: "/var/lib/sympa",
        position: (7, 14),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "user",
        position: (8, 3),
       },
      ],
     },
     String {
      parts: [
       Raw {
        content: "sympa",
        position: (8, 11),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "group",
        position: (9, 3),
       },
      ],
     },
     String {
      parts: [
       Raw {
        content: "sympa",
        position: (9, 12),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "pkg",
        position: (10, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "pkgs",
       position: (10, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "sympa",
         position: (10, 14),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "fqdns",
        position: (11, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "attrNames",
       position: (11, 11),
      },
      arguments: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (11, 21),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "domains",
           position: (11, 25),
          },
         ],
        },
        default: None,
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "usingNginx",
        position: (12, 3),
       },
      ],
     },
     BinaryOperation {
      operator: LogicalAnd,
      operands: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (12, 16),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "web",
           position: (12, 20),
          },
          Raw {
           content: "enable",
           position: (12, 24),
          },
         ],
        },
        default: None,
       },
       BinaryOperation {
        operator: EqualTo,
        operands: [
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (12, 34),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "web",
             position: (12, 38),
            },
            Raw {
             content: "server",
             position: (12, 42),
            },
           ],
          },
          default: None,
         },
         String {
          parts: [
           Raw {
            content: "nginx",
            position: (12, 53),
           },
          ],
         },
        ],
        position: (12, 49),
       },
      ],
      position: (12, 31),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mysqlLocal",
        position: (13, 3),
       },
      ],
     },
     BinaryOperation {
      operator: LogicalAnd,
      operands: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (13, 16),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "database",
           position: (13, 20),
          },
          Raw {
           content: "createLocally",
           position: (13, 29),
          },
         ],
        },
        default: None,
       },
       BinaryOperation {
        operator: EqualTo,
        operands: [
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (13, 46),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "database",
             position: (13, 50),
            },
            Raw {
             content: "type",
             position: (13, 59),
            },
           ],
          },
          default: None,
         },
         String {
          parts: [
           Raw {
            content: "MySQL",
            position: (13, 68),
           },
          ],
         },
        ],
        position: (13, 64),
       },
      ],
      position: (13, 43),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "pgsqlLocal",
        position: (14, 3),
       },
      ],
     },
     BinaryOperation {
      operator: LogicalAnd,
      operands: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (14, 16),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "database",
           position: (14, 20),
          },
          Raw {
           content: "createLocally",
           position: (14, 29),
          },
         ],
        },
        default: None,
       },
       BinaryOperation {
        operator: EqualTo,
        operands: [
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (14, 46),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "database",
             position: (14, 50),
            },
            Raw {
             content: "type",
             position: (14, 59),
            },
           ],
          },
          default: None,
         },
         String {
          parts: [
           Raw {
            content: "PostgreSQL",
            position: (14, 68),
           },
          ],
         },
        ],
        position: (14, 64),
       },
      ],
      position: (14, 43),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "sympaSubServices",
        position: (16, 3),
       },
      ],
     },
     List {
      elements: [
       String {
        parts: [
         Raw {
          content: "sympa-archive.service",
          position: (17, 6),
         },
        ],
       },
       String {
        parts: [
         Raw {
          content: "sympa-bounce.service",
          position: (18, 6),
         },
        ],
       },
       String {
        parts: [
         Raw {
          content: "sympa-bulk.service",
          position: (19, 6),
         },
        ],
       },
       String {
        parts: [
         Raw {
          content: "sympa-task.service",
          position: (20, 6),
         },
        ],
       },
      ],
      position: (16, 22),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "commonServiceConfig",
        position: (24, 3),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "StateDirectory",
           position: (25, 5),
          },
         ],
        },
        String {
         parts: [
          Raw {
           content: "sympa",
           position: (25, 23),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "ProtectHome",
           position: (26, 5),
          },
         ],
        },
        Variable {
         identifier: "true",
         position: (26, 19),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "ProtectSystem",
           position: (27, 5),
          },
         ],
        },
        String {
         parts: [
          Raw {
           content: "full",
           position: (27, 22),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "ProtectControlGroups",
           position: (28, 5),
          },
         ],
        },
        Variable {
         identifier: "true",
         position: (28, 28),
        },
       ),
      ],
      recursive: false,
      position: (24, 25),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "sympaServiceConfig",
        position: (32, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "srv",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: BinaryOperation {
       operator: Update,
       operands: [
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "Type",
              position: (33, 5),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "simple",
              position: (33, 13),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "Restart",
              position: (34, 5),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "always",
              position: (34, 16),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "ExecStart",
              position: (35, 5),
             },
            ],
           },
           String {
            parts: [
             Expression {
              expression: Variable {
               identifier: "pkg",
               position: (35, 20),
              },
             },
             Raw {
              content: "/bin/",
              position: (35, 24),
             },
             Expression {
              expression: Variable {
               identifier: "srv",
               position: (35, 31),
              },
             },
             Raw {
              content: ".pl --foreground",
              position: (35, 35),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "PIDFile",
              position: (36, 5),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "/run/sympa/",
              position: (36, 16),
             },
             Expression {
              expression: Variable {
               identifier: "srv",
               position: (36, 29),
              },
             },
             Raw {
              content: ".pid",
              position: (36, 33),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "User",
              position: (37, 5),
             },
            ],
           },
           Variable {
            identifier: "user",
            position: (37, 12),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "Group",
              position: (38, 5),
             },
            ],
           },
           Variable {
            identifier: "group",
            position: (38, 13),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "StandardError",
              position: (41, 5),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "null",
              position: (41, 22),
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (32, 29),
        },
        Variable {
         identifier: "commonServiceConfig",
         position: (42, 8),
        },
       ],
       position: (42, 5),
      },
      position: (32, 24),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "configVal",
        position: (44, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "value",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: IfThenElse {
       predicate: FunctionApplication {
        function: Variable {
         identifier: "isBool",
         position: (45, 8),
        },
        arguments: [
         Variable {
          identifier: "value",
          position: (45, 15),
         },
        ],
       },
       then: IfThenElse {
        predicate: Variable {
         identifier: "value",
         position: (46, 10),
        },
        then: String {
         parts: [
          Raw {
           content: "on",
           position: (46, 22),
          },
         ],
        },
        else_: String {
         parts: [
          Raw {
           content: "off",
           position: (46, 32),
          },
         ],
        },
        position: (46, 7),
       },
       else_: FunctionApplication {
        function: Variable {
         identifier: "toString",
         position: (47, 10),
        },
        arguments: [
         Variable {
          identifier: "value",
          position: (47, 19),
         },
        ],
       },
       position: (45, 5),
      },
      position: (44, 15),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "configGenerator",
        position: (48, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "c",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "concatStrings",
        position: (48, 24),
       },
       arguments: [
        FunctionApplication {
         function: Variable {
          identifier: "flip",
          position: (48, 39),
         },
         arguments: [
          Variable {
           identifier: "mapAttrsToList",
           position: (48, 44),
          },
          Variable {
           identifier: "c",
           position: (48, 59),
          },
          Function {
           argument: Some(
            "key",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: Function {
            argument: Some(
             "val",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: String {
             parts: [
              Expression {
               expression: Variable {
                identifier: "key",
                position: (48, 75),
               },
              },
              Raw {
               content: "\t",
               position: (48, 79),
              },
              Expression {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "configVal",
                 position: (48, 83),
                },
                arguments: [
                 Variable {
                  identifier: "val",
                  position: (48, 93),
                 },
                ],
               },
              },
              Raw {
               content: "\n",
               position: (48, 97),
              },
             ],
            },
            position: (48, 67),
           },
           position: (48, 62),
          },
         ],
        },
       ],
      },
      position: (48, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mainConfig",
        position: (50, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (50, 16),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (50, 21),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "sympa.conf",
          position: (50, 32),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "configGenerator",
         position: (50, 45),
        },
        arguments: [
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (50, 61),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "settings",
             position: (50, 65),
            },
           ],
          },
          default: None,
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "robotConfig",
        position: (51, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "fqdn",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "domain",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (51, 31),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "writeText",
            position: (51, 36),
           },
          ],
         },
         default: None,
        },
        arguments: [
         String {
          parts: [
           Expression {
            expression: Variable {
             identifier: "fqdn",
             position: (51, 49),
            },
           },
           Raw {
            content: "-robot.conf",
            position: (51, 54),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "configGenerator",
           position: (51, 68),
          },
          arguments: [
           PropertyAccess {
            expression: Variable {
             identifier: "domain",
             position: (51, 84),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "settings",
               position: (51, 91),
              },
             ],
            },
            default: None,
           },
          ],
         },
        ],
       },
       position: (51, 23),
      },
      position: (51, 17),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "transport",
        position: (53, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (53, 15),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (53, 20),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "transport.sympa",
          position: (53, 31),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "concatStringsSep",
         position: (53, 49),
        },
        arguments: [
         String {
          parts: [
           Raw {
            content: "\n",
            position: (53, 67),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "flip",
           position: (53, 72),
          },
          arguments: [
           Variable {
            identifier: "map",
            position: (53, 77),
           },
           Variable {
            identifier: "fqdns",
            position: (53, 81),
           },
           Function {
            argument: Some(
             "domain",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: String {
             parts: [
              Raw {
               content: "",
               position: (54, 1),
              },
              Expression {
               expression: Variable {
                identifier: "domain",
                position: (54, 7),
               },
              },
              Raw {
               content: "                        error:User unknown in recipient table\nsympa@",
               position: (54, 14),
              },
              Expression {
               expression: Variable {
                identifier: "domain",
                position: (55, 13),
               },
              },
              Raw {
               content: "                  sympa:sympa@",
               position: (55, 20),
              },
              Expression {
               expression: Variable {
                identifier: "domain",
                position: (55, 52),
               },
              },
              Raw {
               content: "\nlistmaster@",
               position: (55, 59),
              },
              Expression {
               expression: Variable {
                identifier: "domain",
                position: (56, 18),
               },
              },
              Raw {
               content: "             sympa:listmaster@",
               position: (56, 25),
              },
              Expression {
               expression: Variable {
                identifier: "domain",
                position: (56, 57),
               },
              },
              Raw {
               content: "\nbounce@",
               position: (56, 64),
              },
              Expression {
               expression: Variable {
                identifier: "domain",
                position: (57, 14),
               },
              },
              Raw {
               content: "                 sympabounce:sympa@",
               position: (57, 21),
              },
              Expression {
               expression: Variable {
                identifier: "domain",
                position: (57, 58),
               },
              },
              Raw {
               content: "\nabuse-feedback-report@",
               position: (57, 65),
              },
              Expression {
               expression: Variable {
                identifier: "domain",
                position: (58, 29),
               },
              },
              Raw {
               content: "  sympabounce:sympa@",
               position: (58, 36),
              },
              Expression {
               expression: Variable {
                identifier: "domain",
                position: (58, 58),
               },
              },
              Raw {
               content: "\n",
               position: (58, 65),
              },
             ],
            },
            position: (53, 88),
           },
          ],
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "virtual",
        position: (61, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (61, 13),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (61, 18),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "virtual.sympa",
          position: (61, 29),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "concatStringsSep",
         position: (61, 45),
        },
        arguments: [
         String {
          parts: [
           Raw {
            content: "\n",
            position: (61, 63),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "flip",
           position: (61, 68),
          },
          arguments: [
           Variable {
            identifier: "map",
            position: (61, 73),
           },
           Variable {
            identifier: "fqdns",
            position: (61, 77),
           },
           Function {
            argument: Some(
             "domain",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: String {
             parts: [
              Raw {
               content: "sympa-request@",
               position: (62, 1),
              },
              Expression {
               expression: Variable {
                identifier: "domain",
                position: (62, 21),
               },
              },
              Raw {
               content: "  postmaster@localhost\nsympa-owner@",
               position: (62, 28),
              },
              Expression {
               expression: Variable {
                identifier: "domain",
                position: (63, 19),
               },
              },
              Raw {
               content: "    postmaster@localhost\n",
               position: (63, 26),
              },
             ],
            },
            position: (61, 84),
           },
          ],
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "listAliases",
        position: (66, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (66, 17),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (66, 22),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "list_aliases.tt2",
          position: (66, 33),
         },
        ],
       },
       String {
        parts: [
         Raw {
          content: "#--- [% list.name %]@[% list.domain %]: list transport map created at [% date %]\n[% list.name %]@[% list.domain %] sympa:[% list.name %]@[% list.domain %]\n[% list.name %]-request@[% list.domain %] sympa:[% list.name %]-request@[% list.domain %]\n[% list.name %]-editor@[% list.domain %] sympa:[% list.name %]-editor@[% list.domain %]\n#[% list.name %]-subscribe@[% list.domain %] sympa:[% list.name %]-subscribe@[%list.domain %]\n[% list.name %]-unsubscribe@[% list.domain %] sympa:[% list.name %]-unsubscribe@[% list.domain %]\n[% list.name %][% return_path_suffix %]@[% list.domain %] sympabounce:[% list.name %]@[% list.domain %]\n",
          position: (67, 1),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "enabledFiles",
        position: (76, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "filterAttrs",
       position: (76, 18),
      },
      arguments: [
       Function {
        argument: Some(
         "n",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: Function {
         argument: Some(
          "v",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: PropertyAccess {
          expression: Variable {
           identifier: "v",
           position: (76, 37),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "enable",
             position: (76, 39),
            },
           ],
          },
          default: None,
         },
         position: (76, 34),
        },
        position: (76, 31),
       },
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (76, 47),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "settingsFile",
           position: (76, 51),
          },
         ],
        },
        default: None,
       },
      ],
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (81, 3),
        },
        Raw {
         content: "services",
         position: (81, 11),
        },
        Raw {
         content: "sympa",
         position: (81, 20),
        },
       ],
      },
      With {
       expression: Variable {
        identifier: "types",
        position: (81, 33),
       },
       target: Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "enable",
             position: (83, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkEnableOption",
            position: (83, 14),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "Sympa mailing list manager",
               position: (83, 30),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "lang",
             position: (85, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (85, 12),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (86, 7),
                 },
                ],
               },
               Variable {
                identifier: "str",
                position: (86, 14),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "default",
                  position: (87, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "en_US",
                  position: (87, 18),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "example",
                  position: (88, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "cs",
                  position: (88, 18),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (89, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Default Sympa language.\nSee <link xlink:href='https://github.com/sympa-community/sympa/tree/sympa-6.2/po/sympa' />\nfor available options.\n",
                  position: (90, 1),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (85, 21),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "listMasters",
             position: (96, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (96, 19),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (97, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "listOf",
                 position: (97, 14),
                },
                arguments: [
                 Variable {
                  identifier: "str",
                  position: (97, 21),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "example",
                  position: (98, 7),
                 },
                ],
               },
               List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "postmaster@sympa.example.org",
                    position: (98, 20),
                   },
                  ],
                 },
                ],
                position: (98, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (99, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "The list of the email addresses of the listmasters\n(users authorized to perform global server commands).\n",
                  position: (100, 1),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (96, 28),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "mainDomain",
             position: (105, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (105, 18),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (106, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "nullOr",
                 position: (106, 14),
                },
                arguments: [
                 Variable {
                  identifier: "str",
                  position: (106, 21),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "default",
                  position: (107, 7),
                 },
                ],
               },
               Variable {
                identifier: "null",
                position: (107, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "example",
                  position: (108, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "lists.example.org",
                  position: (108, 18),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (109, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Main domain to be used in <filename>sympa.conf</filename>.\nIf <literal>null</literal>, one of the <option>services.sympa.domains</option> is chosen for you.\n",
                  position: (110, 1),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (105, 27),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "domains",
             position: (115, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (115, 15),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (116, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "attrsOf",
                 position: (116, 14),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "submodule",
                   position: (116, 23),
                  },
                  arguments: [
                   Function {
                    argument: None,
                    arguments: FunctionArguments {
                     arguments: [
                      FunctionArgument {
                       identifier: "config",
                       default: None,
                      },
                      FunctionArgument {
                       identifier: "name",
                       default: None,
                      },
                     ],
                     ellipsis: true,
                    },
                    definition: Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "options",
                          position: (117, 9),
                         },
                        ],
                       },
                       Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "webHost",
                             position: (118, 11),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (118, 21),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (119, 13),
                                 },
                                ],
                               },
                               FunctionApplication {
                                function: Variable {
                                 identifier: "nullOr",
                                 position: (119, 20),
                                },
                                arguments: [
                                 Variable {
                                  identifier: "str",
                                  position: (119, 27),
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (120, 13),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "null",
                                position: (120, 23),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "example",
                                  position: (121, 13),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "archive.example.org",
                                  position: (121, 24),
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (122, 13),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "Domain part of the web interface URL (no web interface for this domain if <literal>null</literal>).\nDNS record of type A (or AAAA or CNAME) has to exist with this value.\n",
                                  position: (123, 1),
                                 },
                                ],
                               },
                              ),
                             ],
                             recursive: false,
                             position: (118, 30),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "webLocation",
                             position: (127, 11),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (127, 25),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (128, 13),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "str",
                                position: (128, 20),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (129, 13),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "/",
                                  position: (129, 24),
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "example",
                                  position: (130, 13),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "/sympa",
                                  position: (130, 24),
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (131, 13),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "URL path part of the web interface.",
                                  position: (131, 28),
                                 },
                                ],
                               },
                              ),
                             ],
                             recursive: false,
                             position: (127, 34),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "settings",
                             position: (133, 11),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (133, 22),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (134, 13),
                                 },
                                ],
                               },
                               FunctionApplication {
                                function: Variable {
                                 identifier: "attrsOf",
                                 position: (134, 20),
                                },
                                arguments: [
                                 FunctionApplication {
                                  function: Variable {
                                   identifier: "oneOf",
                                   position: (134, 29),
                                  },
                                  arguments: [
                                   List {
                                    elements: [
                                     Variable {
                                      identifier: "str",
                                      position: (134, 37),
                                     },
                                     Variable {
                                      identifier: "int",
                                      position: (134, 41),
                                     },
                                     Variable {
                                      identifier: "bool",
                                      position: (134, 45),
                                     },
                                    ],
                                    position: (134, 35),
                                   },
                                  ],
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (135, 13),
                                 },
                                ],
                               },
                               Map {
                                bindings: [],
                                recursive: false,
                                position: (135, 23),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "example",
                                  position: (136, 13),
                                 },
                                ],
                               },
                               Map {
                                bindings: [
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "default_max_list_members",
                                     position: (137, 15),
                                    },
                                   ],
                                  },
                                  Int {
                                   value: 3,
                                   position: (137, 42),
                                  },
                                 ),
                                ],
                                recursive: false,
                                position: (136, 23),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (139, 13),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "The <filename>robot.conf</filename> configuration file as key value set.\nSee <link xlink:href='https://sympa-community.github.io/gpldoc/man/sympa.conf.5.html' />\nfor list of configuration parameters.\n",
                                  position: (140, 1),
                                 },
                                ],
                               },
                              ),
                             ],
                             recursive: false,
                             position: (133, 31),
                            },
                           ],
                          },
                         ),
                        ],
                        recursive: false,
                        position: (117, 19),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "config",
                          position: (147, 9),
                         },
                         Raw {
                          content: "settings",
                          position: (147, 16),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkIf",
                         position: (147, 27),
                        },
                        arguments: [
                         BinaryOperation {
                          operator: LogicalAnd,
                          operands: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (147, 33),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "web",
                               position: (147, 37),
                              },
                              Raw {
                               content: "enable",
                               position: (147, 41),
                              },
                             ],
                            },
                            default: None,
                           },
                           BinaryOperation {
                            operator: NotEqualTo,
                            operands: [
                             PropertyAccess {
                              expression: Variable {
                               identifier: "config",
                               position: (147, 51),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "webHost",
                                 position: (147, 58),
                                },
                               ],
                              },
                              default: None,
                             },
                             Variable {
                              identifier: "null",
                              position: (147, 69),
                             },
                            ],
                            position: (147, 66),
                           },
                          ],
                          position: (147, 48),
                         },
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "wwsympa_url",
                               position: (148, 11),
                              },
                             ],
                            },
                            FunctionApplication {
                             function: Variable {
                              identifier: "mkDefault",
                              position: (148, 25),
                             },
                             arguments: [
                              String {
                               parts: [
                                Raw {
                                 content: "https://",
                                 position: (148, 36),
                                },
                                Expression {
                                 expression: PropertyAccess {
                                  expression: Variable {
                                   identifier: "config",
                                   position: (148, 46),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "webHost",
                                     position: (148, 53),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                },
                                Expression {
                                 expression: FunctionApplication {
                                  function: PropertyAccess {
                                   expression: Variable {
                                    identifier: "strings",
                                    position: (148, 63),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "removeSuffix",
                                      position: (148, 71),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  arguments: [
                                   String {
                                    parts: [
                                     Raw {
                                      content: "/",
                                      position: (148, 85),
                                     },
                                    ],
                                   },
                                   PropertyAccess {
                                    expression: Variable {
                                     identifier: "config",
                                     position: (148, 88),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "webLocation",
                                       position: (148, 95),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                  ],
                                 },
                                },
                               ],
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (147, 75),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (116, 57),
                    },
                    position: (116, 34),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (152, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Email domains handled by this instance. There have\nto be MX records for keys of this attribute set.\n",
                  position: (153, 1),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "example",
                  position: (156, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "literalExpression",
                 position: (156, 17),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "{\n  \"lists.example.org\" = {\n    webHost = \"lists.example.org\";\n    webLocation = \"/\";\n  };\n  \"sympa.example.com\" = {\n    webHost = \"example.com\";\n    webLocation = \"/sympa\";\n  };\n}\n",
                    position: (157, 1),
                   },
                  ],
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (115, 24),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "database",
             position: (170, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (171, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (171, 14),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (172, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "enum",
                    position: (172, 16),
                   },
                   arguments: [
                    List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "SQLite",
                         position: (172, 24),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "PostgreSQL",
                         position: (172, 33),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "MySQL",
                         position: (172, 46),
                        },
                       ],
                      },
                     ],
                     position: (172, 21),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (173, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "SQLite",
                     position: (173, 20),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "example",
                     position: (174, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "MySQL",
                     position: (174, 20),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (175, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Database engine to use.",
                     position: (175, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (171, 23),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "host",
                position: (178, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (178, 14),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (179, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (179, 16),
                   },
                   arguments: [
                    Variable {
                     identifier: "str",
                     position: (179, 23),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (180, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "null",
                   position: (180, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (181, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Database host address.\n\nFor MySQL, use <literal>localhost</literal> to connect using Unix domain socket.\n\nFor PostgreSQL, use path to directory (e.g. <filename>/run/postgresql</filename>)\nto connect using Unix domain socket located in this directory.\n\nUse <literal>null</literal> to fall back on Sympa default, or when using\n<option>services.sympa.database.createLocally</option>.\n",
                     position: (182, 1),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (178, 23),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "port",
                position: (194, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (194, 14),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (195, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (195, 16),
                   },
                   arguments: [
                    Variable {
                     identifier: "port",
                     position: (195, 23),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (196, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "null",
                   position: (196, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (197, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Database port. Use <literal>null</literal> for default port.",
                     position: (197, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (194, 23),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "name",
                position: (200, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (200, 14),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (201, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "str",
                   position: (201, 16),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (202, 9),
                    },
                   ],
                  },
                  IfThenElse {
                   predicate: BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (202, 22),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "database",
                         position: (202, 26),
                        },
                        Raw {
                         content: "type",
                         position: (202, 35),
                        },
                       ],
                      },
                      default: None,
                     },
                     String {
                      parts: [
                       Raw {
                        content: "SQLite",
                        position: (202, 44),
                       },
                      ],
                     },
                    ],
                    position: (202, 40),
                   },
                   then: String {
                    parts: [
                     Expression {
                      expression: Variable {
                       identifier: "dataDir",
                       position: (202, 60),
                      },
                     },
                     Raw {
                      content: "/sympa.sqlite",
                      position: (202, 68),
                     },
                    ],
                   },
                   else_: String {
                    parts: [
                     Raw {
                      content: "sympa",
                      position: (202, 89),
                     },
                    ],
                   },
                   position: (202, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "defaultText",
                     position: (203, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "literalExpression",
                    position: (203, 23),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "if database.type == \"SQLite\" then \"",
                       position: (203, 43),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "dataDir",
                        position: (203, 80),
                       },
                      },
                      Raw {
                       content: "/sympa.sqlite\" else \"sympa\"",
                       position: (203, 88),
                      },
                     ],
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (204, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Database name. When using SQLite this must be an absolute\npath to the database file.\n",
                     position: (205, 1),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (200, 23),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "user",
                position: (210, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (210, 14),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (211, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (211, 16),
                   },
                   arguments: [
                    Variable {
                     identifier: "str",
                     position: (211, 23),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (212, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "user",
                   position: (212, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (213, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Database user. The system user name is used as a default.",
                     position: (213, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (210, 23),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "passwordFile",
                position: (216, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (216, 22),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (217, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (217, 16),
                   },
                   arguments: [
                    Variable {
                     identifier: "path",
                     position: (217, 23),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (218, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "null",
                   position: (218, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "example",
                     position: (219, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "/run/keys/sympa-dbpassword",
                     position: (219, 20),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (220, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "A file containing the password for <option>services.sympa.database.user</option>.\n",
                     position: (221, 1),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (216, 31),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "createLocally",
                position: (225, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (225, 23),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (226, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "bool",
                   position: (226, 16),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (227, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (227, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (228, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Whether to create a local database automatically.",
                     position: (228, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (225, 32),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (170, 16),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "web",
             position: (232, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "enable",
                position: (233, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (233, 16),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (234, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "bool",
                   position: (234, 16),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (235, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (235, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (236, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Whether to enable Sympa web interface.",
                     position: (236, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (233, 25),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "server",
                position: (239, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (239, 16),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (240, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "enum",
                    position: (240, 16),
                   },
                   arguments: [
                    List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "nginx",
                         position: (240, 24),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "none",
                         position: (240, 32),
                        },
                       ],
                      },
                     ],
                     position: (240, 21),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (241, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "nginx",
                     position: (241, 20),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (242, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "The webserver used for the Sympa web interface. Set it to `none` if you want to configure it yourself.\nFurther nginx configuration can be done by adapting\n<option>services.nginx.virtualHosts.<replaceable>name</replaceable></option>.\n",
                     position: (243, 1),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (239, 25),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "https",
                position: (249, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (249, 15),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (250, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "bool",
                   position: (250, 16),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (251, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (251, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (252, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Whether to use HTTPS. When nginx integration is enabled, this option forces SSL and enables ACME.\nPlease note that Sympa web interface always uses https links even when this option is disabled.\n",
                     position: (253, 1),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (249, 24),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "fcgiProcs",
                position: (258, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (258, 19),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (259, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "ints",
                    position: (259, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "positive",
                      position: (259, 21),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (260, 9),
                    },
                   ],
                  },
                  Int {
                   value: 2,
                   position: (260, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (261, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Number of FastCGI processes to fork.",
                     position: (261, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (258, 28),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (232, 11),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "mta",
             position: (265, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (266, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (266, 14),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (267, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "enum",
                    position: (267, 16),
                   },
                   arguments: [
                    List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "postfix",
                         position: (267, 24),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "none",
                         position: (267, 34),
                        },
                       ],
                      },
                     ],
                     position: (267, 21),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (268, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "postfix",
                     position: (268, 20),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (269, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Mail transfer agent (MTA) integration. Use <literal>none</literal> if you want to configure it yourself.\n\nThe <literal>postfix</literal> integration sets up local Postfix instance that will pass incoming\nmessages from configured domains to Sympa. You still need to configure at least outgoing message\nhandling using e.g. <option>services.postfix.relayHost</option>.\n",
                     position: (270, 1),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (266, 23),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (265, 11),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "settings",
             position: (279, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (279, 16),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (280, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "attrsOf",
                 position: (280, 14),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "oneOf",
                   position: (280, 23),
                  },
                  arguments: [
                   List {
                    elements: [
                     Variable {
                      identifier: "str",
                      position: (280, 31),
                     },
                     Variable {
                      identifier: "int",
                      position: (280, 35),
                     },
                     Variable {
                      identifier: "bool",
                      position: (280, 39),
                     },
                    ],
                    position: (280, 29),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "default",
                  position: (281, 7),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (281, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "example",
                  position: (282, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "literalExpression",
                 position: (282, 17),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "{\n  default_home = \"lists\";\n  viewlogs_page_size = 50;\n}\n",
                    position: (283, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (288, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "The <filename>sympa.conf</filename> configuration file as key value set.\nSee <link xlink:href='https://sympa-community.github.io/gpldoc/man/sympa.conf.5.html' />\nfor list of configuration parameters.\n",
                  position: (289, 1),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (279, 25),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "settingsFile",
             position: (295, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (295, 20),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (296, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "attrsOf",
                 position: (296, 14),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "submodule",
                   position: (296, 23),
                  },
                  arguments: [
                   Function {
                    argument: None,
                    arguments: FunctionArguments {
                     arguments: [
                      FunctionArgument {
                       identifier: "config",
                       default: None,
                      },
                      FunctionArgument {
                       identifier: "name",
                       default: None,
                      },
                     ],
                     ellipsis: true,
                    },
                    definition: Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "options",
                          position: (297, 9),
                         },
                        ],
                       },
                       Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "enable",
                             position: (298, 11),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (298, 20),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (299, 13),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "bool",
                                position: (299, 20),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (300, 13),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "true",
                                position: (300, 23),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (301, 13),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "Whether this file should be generated. This option allows specific files to be disabled.",
                                  position: (301, 28),
                                 },
                                ],
                               },
                              ),
                             ],
                             recursive: false,
                             position: (298, 29),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "text",
                             position: (303, 11),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (303, 18),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (304, 13),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "null",
                                position: (304, 23),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (305, 13),
                                 },
                                ],
                               },
                               FunctionApplication {
                                function: Variable {
                                 identifier: "nullOr",
                                 position: (305, 20),
                                },
                                arguments: [
                                 Variable {
                                  identifier: "lines",
                                  position: (305, 27),
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (306, 13),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "Text of the file.",
                                  position: (306, 28),
                                 },
                                ],
                               },
                              ),
                             ],
                             recursive: false,
                             position: (303, 27),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "source",
                             position: (308, 11),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (308, 20),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (309, 13),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "path",
                                position: (309, 20),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (310, 13),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "Path of the source file.",
                                  position: (310, 28),
                                 },
                                ],
                               },
                              ),
                             ],
                             recursive: false,
                             position: (308, 29),
                            },
                           ],
                          },
                         ),
                        ],
                        recursive: false,
                        position: (297, 19),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "config",
                          position: (314, 9),
                         },
                         Raw {
                          content: "source",
                          position: (314, 16),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkIf",
                         position: (314, 25),
                        },
                        arguments: [
                         BinaryOperation {
                          operator: NotEqualTo,
                          operands: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "config",
                             position: (314, 31),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "text",
                               position: (314, 38),
                              },
                             ],
                            },
                            default: None,
                           },
                           Variable {
                            identifier: "null",
                            position: (314, 46),
                           },
                          ],
                          position: (314, 43),
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkDefault",
                           position: (314, 53),
                          },
                          arguments: [
                           FunctionApplication {
                            function: PropertyAccess {
                             expression: Variable {
                              identifier: "pkgs",
                              position: (314, 64),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "writeText",
                                position: (314, 69),
                               },
                              ],
                             },
                             default: None,
                            },
                            arguments: [
                             String {
                              parts: [
                               Raw {
                                content: "sympa-",
                                position: (314, 80),
                               },
                               Expression {
                                expression: FunctionApplication {
                                 function: Variable {
                                  identifier: "baseNameOf",
                                  position: (314, 88),
                                 },
                                 arguments: [
                                  Variable {
                                   identifier: "name",
                                   position: (314, 99),
                                  },
                                 ],
                                },
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "config",
                               position: (314, 106),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "text",
                                 position: (314, 113),
                                },
                               ],
                              },
                              default: None,
                             },
                            ],
                           },
                          ],
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (296, 57),
                    },
                    position: (296, 34),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "default",
                  position: (316, 7),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (316, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "example",
                  position: (317, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "literalExpression",
                 position: (317, 17),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "{\n  \"list_data/lists.example.org/help\" = {\n    text = \"subject This list provides help to users\";\n  };\n}\n",
                    position: (318, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (324, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Set of files to be linked in <filename>",
                  position: (324, 22),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "dataDir",
                   position: (324, 63),
                  },
                 },
                 Raw {
                  content: "</filename>.",
                  position: (324, 71),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (295, 29),
            },
           ],
          },
         ),
        ],
        recursive: false,
        position: (81, 40),
       },
       position: (81, 28),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (330, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (330, 12),
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (330, 17),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (330, 21),
           },
          ],
         },
         default: None,
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (332, 5),
             },
             Raw {
              content: "sympa",
              position: (332, 14),
             },
             Raw {
              content: "settings",
              position: (332, 20),
             },
            ],
           },
           BinaryOperation {
            operator: Update,
            operands: [
             FunctionApplication {
              function: Variable {
               identifier: "mapAttrs",
               position: (332, 32),
              },
              arguments: [
               Function {
                argument: Some(
                 "_",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: Function {
                 argument: Some(
                  "v",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: FunctionApplication {
                  function: Variable {
                   identifier: "mkDefault",
                   position: (332, 48),
                  },
                  arguments: [
                   Variable {
                    identifier: "v",
                    position: (332, 58),
                   },
                  ],
                 },
                 position: (332, 45),
                },
                position: (332, 42),
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "domain",
                     position: (333, 7),
                    },
                   ],
                  },
                  IfThenElse {
                   predicate: BinaryOperation {
                    operator: NotEqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (333, 23),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "mainDomain",
                         position: (333, 27),
                        },
                       ],
                      },
                      default: None,
                     },
                     Variable {
                      identifier: "null",
                      position: (333, 41),
                     },
                    ],
                    position: (333, 38),
                   },
                   then: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (333, 51),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "mainDomain",
                       position: (333, 55),
                      },
                     ],
                    },
                    default: None,
                   },
                   else_: FunctionApplication {
                    function: Variable {
                     identifier: "head",
                     position: (333, 71),
                    },
                    arguments: [
                     Variable {
                      identifier: "fqdns",
                      position: (333, 76),
                     },
                    ],
                   },
                   position: (333, 20),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "listmaster",
                     position: (334, 7),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "concatStringsSep",
                    position: (334, 20),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: ",",
                       position: (334, 38),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (334, 41),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "listMasters",
                        position: (334, 45),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "lang",
                     position: (335, 7),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (335, 20),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "lang",
                      position: (335, 24),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "home",
                     position: (337, 7),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Expression {
                     expression: Variable {
                      identifier: "dataDir",
                      position: (337, 24),
                     },
                    },
                    Raw {
                     content: "/list_data",
                     position: (337, 32),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "arc_path",
                     position: (338, 7),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Expression {
                     expression: Variable {
                      identifier: "dataDir",
                      position: (338, 24),
                     },
                    },
                    Raw {
                     content: "/arc",
                     position: (338, 32),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "bounce_path",
                     position: (339, 7),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Expression {
                     expression: Variable {
                      identifier: "dataDir",
                      position: (339, 24),
                     },
                    },
                    Raw {
                     content: "/bounce",
                     position: (339, 32),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "sendmail",
                     position: (341, 7),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (341, 21),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "system-sendmail",
                         position: (341, 26),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/bin/sendmail",
                     position: (341, 42),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "db_type",
                     position: (343, 7),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (343, 17),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "database",
                      position: (343, 21),
                     },
                     Raw {
                      content: "type",
                      position: (343, 30),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "db_name",
                     position: (344, 7),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (344, 17),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "database",
                      position: (344, 21),
                     },
                     Raw {
                      content: "name",
                      position: (344, 30),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                ],
                recursive: false,
                position: (332, 61),
               },
              ],
             },
             BinaryOperation {
              operator: Update,
              operands: [
               FunctionApplication {
                function: Variable {
                 identifier: "optionalAttrs",
                 position: (346, 9),
                },
                arguments: [
                 BinaryOperation {
                  operator: NotEqualTo,
                  operands: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (346, 24),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "database",
                       position: (346, 28),
                      },
                      Raw {
                       content: "host",
                       position: (346, 37),
                      },
                     ],
                    },
                    default: None,
                   },
                   Variable {
                    identifier: "null",
                    position: (346, 45),
                   },
                  ],
                  position: (346, 42),
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "db_host",
                       position: (347, 7),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (347, 17),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "database",
                        position: (347, 21),
                       },
                       Raw {
                        content: "host",
                        position: (347, 30),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                  ],
                  recursive: false,
                  position: (346, 51),
                 },
                ],
               },
               BinaryOperation {
                operator: Update,
                operands: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "optionalAttrs",
                   position: (349, 9),
                  },
                  arguments: [
                   Variable {
                    identifier: "mysqlLocal",
                    position: (349, 23),
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "db_host",
                         position: (350, 7),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "localhost",
                         position: (350, 18),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (349, 34),
                   },
                  ],
                 },
                 BinaryOperation {
                  operator: Update,
                  operands: [
                   FunctionApplication {
                    function: Variable {
                     identifier: "optionalAttrs",
                     position: (352, 9),
                    },
                    arguments: [
                     Variable {
                      identifier: "pgsqlLocal",
                      position: (352, 23),
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "db_host",
                           position: (353, 7),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "/run/postgresql",
                           position: (353, 18),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (352, 34),
                     },
                    ],
                   },
                   BinaryOperation {
                    operator: Update,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "optionalAttrs",
                       position: (355, 9),
                      },
                      arguments: [
                       BinaryOperation {
                        operator: NotEqualTo,
                        operands: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (355, 24),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "database",
                             position: (355, 28),
                            },
                            Raw {
                             content: "port",
                             position: (355, 37),
                            },
                           ],
                          },
                          default: None,
                         },
                         Variable {
                          identifier: "null",
                          position: (355, 45),
                         },
                        ],
                        position: (355, 42),
                       },
                       Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "db_port",
                             position: (356, 7),
                            },
                           ],
                          },
                          PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (356, 17),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "database",
                              position: (356, 21),
                             },
                             Raw {
                              content: "port",
                              position: (356, 30),
                             },
                            ],
                           },
                           default: None,
                          },
                         ),
                        ],
                        recursive: false,
                        position: (355, 51),
                       },
                      ],
                     },
                     BinaryOperation {
                      operator: Update,
                      operands: [
                       FunctionApplication {
                        function: Variable {
                         identifier: "optionalAttrs",
                         position: (358, 9),
                        },
                        arguments: [
                         BinaryOperation {
                          operator: NotEqualTo,
                          operands: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (358, 24),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "database",
                               position: (358, 28),
                              },
                              Raw {
                               content: "user",
                               position: (358, 37),
                              },
                             ],
                            },
                            default: None,
                           },
                           Variable {
                            identifier: "null",
                            position: (358, 45),
                           },
                          ],
                          position: (358, 42),
                         },
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "db_user",
                               position: (359, 7),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (359, 17),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "database",
                                position: (359, 21),
                               },
                               Raw {
                                content: "user",
                                position: (359, 30),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                          ],
                          recursive: false,
                          position: (358, 51),
                         },
                        ],
                       },
                       BinaryOperation {
                        operator: Update,
                        operands: [
                         FunctionApplication {
                          function: Variable {
                           identifier: "optionalAttrs",
                           position: (361, 9),
                          },
                          arguments: [
                           BinaryOperation {
                            operator: EqualTo,
                            operands: [
                             PropertyAccess {
                              expression: Variable {
                               identifier: "cfg",
                               position: (361, 24),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "mta",
                                 position: (361, 28),
                                },
                                Raw {
                                 content: "type",
                                 position: (361, 32),
                                },
                               ],
                              },
                              default: None,
                             },
                             String {
                              parts: [
                               Raw {
                                content: "postfix",
                                position: (361, 41),
                               },
                              ],
                             },
                            ],
                            position: (361, 37),
                           },
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "sendmail_aliases",
                                 position: (362, 7),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Expression {
                                 expression: Variable {
                                  identifier: "dataDir",
                                  position: (362, 29),
                                 },
                                },
                                Raw {
                                 content: "/sympa_transport",
                                 position: (362, 37),
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "aliases_program",
                                 position: (363, 7),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Expression {
                                 expression: PropertyAccess {
                                  expression: Variable {
                                   identifier: "pkgs",
                                   position: (363, 29),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "postfix",
                                     position: (363, 34),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                },
                                Raw {
                                 content: "/bin/postmap",
                                 position: (363, 42),
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "aliases_db_type",
                                 position: (364, 7),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "hash",
                                 position: (364, 27),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (361, 51),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "optionalAttrs",
                           position: (366, 9),
                          },
                          arguments: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (366, 23),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "web",
                               position: (366, 27),
                              },
                              Raw {
                               content: "enable",
                               position: (366, 31),
                              },
                             ],
                            },
                            default: None,
                           },
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "static_content_path",
                                 position: (367, 7),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Expression {
                                 expression: Variable {
                                  identifier: "dataDir",
                                  position: (367, 32),
                                 },
                                },
                                Raw {
                                 content: "/static_content",
                                 position: (367, 40),
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "css_path",
                                 position: (368, 7),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Expression {
                                 expression: Variable {
                                  identifier: "dataDir",
                                  position: (368, 32),
                                 },
                                },
                                Raw {
                                 content: "/static_content/css",
                                 position: (368, 40),
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "pictures_path",
                                 position: (369, 7),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Expression {
                                 expression: Variable {
                                  identifier: "dataDir",
                                  position: (369, 32),
                                 },
                                },
                                Raw {
                                 content: "/static_content/pictures",
                                 position: (369, 40),
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "mhonarc",
                                 position: (370, 7),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Expression {
                                 expression: PropertyAccess {
                                  expression: Variable {
                                   identifier: "pkgs",
                                   position: (370, 32),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "perlPackages",
                                     position: (370, 37),
                                    },
                                    Raw {
                                     content: "MHonArc",
                                     position: (370, 50),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                },
                                Raw {
                                 content: "/bin/mhonarc",
                                 position: (370, 58),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (366, 38),
                           },
                          ],
                         },
                        ],
                        position: (366, 5),
                       },
                      ],
                      position: (361, 5),
                     },
                    ],
                    position: (358, 5),
                   },
                  ],
                  position: (355, 5),
                 },
                ],
                position: (352, 5),
               },
              ],
              position: (349, 5),
             },
            ],
            position: (346, 5),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (373, 5),
             },
             Raw {
              content: "sympa",
              position: (373, 14),
             },
             Raw {
              content: "settingsFile",
              position: (373, 20),
             },
            ],
           },
           BinaryOperation {
            operator: Update,
            operands: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Expression {
                   expression: String {
                    parts: [
                     Raw {
                      content: "virtual.sympa",
                      position: (374, 8),
                     },
                    ],
                   },
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mkDefault",
                  position: (374, 32),
                 },
                 arguments: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "source",
                        position: (374, 44),
                       },
                      ],
                     },
                     Variable {
                      identifier: "virtual",
                      position: (374, 53),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (374, 42),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Expression {
                   expression: String {
                    parts: [
                     Raw {
                      content: "transport.sympa",
                      position: (375, 8),
                     },
                    ],
                   },
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mkDefault",
                  position: (375, 32),
                 },
                 arguments: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "source",
                        position: (375, 44),
                       },
                      ],
                     },
                     Variable {
                      identifier: "transport",
                      position: (375, 53),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (375, 42),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Expression {
                   expression: String {
                    parts: [
                     Raw {
                      content: "etc/list_aliases.tt2",
                      position: (376, 8),
                     },
                    ],
                   },
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mkDefault",
                  position: (376, 32),
                 },
                 arguments: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "source",
                        position: (376, 44),
                       },
                      ],
                     },
                     Variable {
                      identifier: "listAliases",
                      position: (376, 53),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (376, 42),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (373, 35),
             },
             FunctionApplication {
              function: Variable {
               identifier: "flip",
               position: (378, 9),
              },
              arguments: [
               Variable {
                identifier: "mapAttrs'",
                position: (378, 14),
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (378, 24),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "domains",
                   position: (378, 28),
                  },
                 ],
                },
                default: None,
               },
               Function {
                argument: Some(
                 "fqdn",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: Function {
                 argument: Some(
                  "domain",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: FunctionApplication {
                  function: Variable {
                   identifier: "nameValuePair",
                   position: (379, 11),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "etc/",
                      position: (379, 26),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "fqdn",
                       position: (379, 32),
                      },
                     },
                     Raw {
                      content: "/robot.conf",
                      position: (379, 37),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "mkDefault",
                     position: (379, 51),
                    },
                    arguments: [
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "source",
                           position: (379, 63),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "robotConfig",
                          position: (379, 72),
                         },
                         arguments: [
                          Variable {
                           identifier: "fqdn",
                           position: (379, 84),
                          },
                          Variable {
                           identifier: "domain",
                           position: (379, 89),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (379, 61),
                     },
                    ],
                   },
                  ],
                 },
                 position: (378, 43),
                },
                position: (378, 37),
               },
              ],
             },
            ],
            position: (378, 5),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (381, 5),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "systemPackages",
                 position: (382, 7),
                },
               ],
              },
              List {
               elements: [
                Variable {
                 identifier: "pkg",
                 position: (382, 26),
                },
               ],
               position: (382, 24),
              },
             ),
            ],
            recursive: false,
            position: (381, 19),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (385, 5),
             },
             Raw {
              content: "users",
              position: (385, 11),
             },
             Expression {
              expression: Variable {
               identifier: "user",
               position: (385, 19),
              },
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (386, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Sympa mailing list manager user",
                 position: (386, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "group",
                 position: (387, 7),
                },
               ],
              },
              Variable {
               identifier: "group",
               position: (387, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "home",
                 position: (388, 7),
                },
               ],
              },
              Variable {
               identifier: "dataDir",
               position: (388, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "createHome",
                 position: (389, 7),
                },
               ],
              },
              Variable {
               identifier: "false",
               position: (389, 20),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "isSystemUser",
                 position: (390, 7),
                },
               ],
              },
              Variable {
               identifier: "true",
               position: (390, 22),
              },
             ),
            ],
            recursive: false,
            position: (385, 27),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (393, 5),
             },
             Raw {
              content: "groups",
              position: (393, 11),
             },
             Expression {
              expression: Variable {
               identifier: "group",
               position: (393, 20),
              },
             },
            ],
           },
           Map {
            bindings: [],
            recursive: false,
            position: (393, 29),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "assertions",
              position: (395, 5),
             },
            ],
           },
           List {
            elements: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (396, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Implication,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (396, 21),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "database",
                      position: (396, 25),
                     },
                     Raw {
                      content: "createLocally",
                      position: (396, 34),
                     },
                    ],
                   },
                   default: None,
                  },
                  BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (396, 51),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "database",
                        position: (396, 55),
                       },
                       Raw {
                        content: "user",
                        position: (396, 64),
                       },
                      ],
                     },
                     default: None,
                    },
                    Variable {
                     identifier: "user",
                     position: (396, 72),
                    },
                   ],
                   position: (396, 69),
                  },
                 ],
                 position: (396, 48),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (397, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "services.sympa.database.user must be set to ",
                   position: (397, 20),
                  },
                  Expression {
                   expression: Variable {
                    identifier: "user",
                    position: (397, 66),
                   },
                  },
                  Raw {
                   content: " if services.sympa.database.createLocally is set to true",
                   position: (397, 71),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (396, 7),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (399, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Implication,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (399, 21),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "database",
                      position: (399, 25),
                     },
                     Raw {
                      content: "createLocally",
                      position: (399, 34),
                     },
                    ],
                   },
                   default: None,
                  },
                  BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (399, 51),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "database",
                        position: (399, 55),
                       },
                       Raw {
                        content: "passwordFile",
                        position: (399, 64),
                       },
                      ],
                     },
                     default: None,
                    },
                    Variable {
                     identifier: "null",
                     position: (399, 80),
                    },
                   ],
                   position: (399, 77),
                  },
                 ],
                 position: (399, 48),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (400, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "a password cannot be specified if services.sympa.database.createLocally is set to true",
                   position: (400, 20),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (399, 7),
             },
            ],
            position: (395, 18),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (404, 5),
             },
             Raw {
              content: "tmpfiles",
              position: (404, 13),
             },
             Raw {
              content: "rules",
              position: (404, 22),
             },
            ],
           },
           BinaryOperation {
            operator: Concatenation,
            operands: [
             List {
              elements: [
               String {
                parts: [
                 Raw {
                  content: "d  ",
                  position: (405, 8),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "dataDir",
                   position: (405, 13),
                  },
                 },
                 Raw {
                  content: "                   0711 ",
                  position: (405, 21),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "user",
                   position: (405, 47),
                  },
                 },
                 Raw {
                  content: " ",
                  position: (405, 52),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "group",
                   position: (405, 55),
                  },
                 },
                 Raw {
                  content: " - -",
                  position: (405, 61),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "d  ",
                  position: (406, 8),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "dataDir",
                   position: (406, 13),
                  },
                 },
                 Raw {
                  content: "/etc               0700 ",
                  position: (406, 21),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "user",
                   position: (406, 47),
                  },
                 },
                 Raw {
                  content: " ",
                  position: (406, 52),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "group",
                   position: (406, 55),
                  },
                 },
                 Raw {
                  content: " - -",
                  position: (406, 61),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "d  ",
                  position: (407, 8),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "dataDir",
                   position: (407, 13),
                  },
                 },
                 Raw {
                  content: "/spool             0700 ",
                  position: (407, 21),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "user",
                   position: (407, 47),
                  },
                 },
                 Raw {
                  content: " ",
                  position: (407, 52),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "group",
                   position: (407, 55),
                  },
                 },
                 Raw {
                  content: " - -",
                  position: (407, 61),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "d  ",
                  position: (408, 8),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "dataDir",
                   position: (408, 13),
                  },
                 },
                 Raw {
                  content: "/list_data         0700 ",
                  position: (408, 21),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "user",
                   position: (408, 47),
                  },
                 },
                 Raw {
                  content: " ",
                  position: (408, 52),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "group",
                   position: (408, 55),
                  },
                 },
                 Raw {
                  content: " - -",
                  position: (408, 61),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "d  ",
                  position: (409, 8),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "dataDir",
                   position: (409, 13),
                  },
                 },
                 Raw {
                  content: "/arc               0700 ",
                  position: (409, 21),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "user",
                   position: (409, 47),
                  },
                 },
                 Raw {
                  content: " ",
                  position: (409, 52),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "group",
                   position: (409, 55),
                  },
                 },
                 Raw {
                  content: " - -",
                  position: (409, 61),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "d  ",
                  position: (410, 8),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "dataDir",
                   position: (410, 13),
                  },
                 },
                 Raw {
                  content: "/bounce            0700 ",
                  position: (410, 21),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "user",
                   position: (410, 47),
                  },
                 },
                 Raw {
                  content: " ",
                  position: (410, 52),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "group",
                   position: (410, 55),
                  },
                 },
                 Raw {
                  content: " - -",
                  position: (410, 61),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "f  ",
                  position: (411, 8),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "dataDir",
                   position: (411, 13),
                  },
                 },
                 Raw {
                  content: "/sympa_transport   0600 ",
                  position: (411, 21),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "user",
                   position: (411, 47),
                  },
                 },
                 Raw {
                  content: " ",
                  position: (411, 52),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "group",
                   position: (411, 55),
                  },
                 },
                 Raw {
                  content: " - -",
                  position: (411, 61),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "R  ",
                  position: (415, 8),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "dataDir",
                   position: (415, 13),
                  },
                 },
                 Raw {
                  content: "/static_content    -    -       -        - -",
                  position: (415, 21),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "C  ",
                  position: (416, 8),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "dataDir",
                   position: (416, 13),
                  },
                 },
                 Raw {
                  content: "/static_content    0711 ",
                  position: (416, 21),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "user",
                   position: (416, 47),
                  },
                 },
                 Raw {
                  content: " ",
                  position: (416, 52),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "group",
                   position: (416, 55),
                  },
                 },
                 Raw {
                  content: " - ",
                  position: (416, 61),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "pkg",
                   position: (416, 66),
                  },
                 },
                 Raw {
                  content: "/var/lib/sympa/static_content",
                  position: (416, 70),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "e  ",
                  position: (417, 8),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "dataDir",
                   position: (417, 13),
                  },
                 },
                 Raw {
                  content: "/static_content/*  0711 ",
                  position: (417, 21),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "user",
                   position: (417, 47),
                  },
                 },
                 Raw {
                  content: " ",
                  position: (417, 52),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "group",
                   position: (417, 55),
                  },
                 },
                 Raw {
                  content: " - -",
                  position: (417, 61),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "d  /run/sympa                   0755 ",
                  position: (419, 8),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "user",
                   position: (419, 47),
                  },
                 },
                 Raw {
                  content: " ",
                  position: (419, 52),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "group",
                   position: (419, 55),
                  },
                 },
                 Raw {
                  content: " - -",
                  position: (419, 61),
                 },
                ],
               },
              ],
              position: (404, 30),
             },
             BinaryOperation {
              operator: Concatenation,
              operands: [
               FunctionApplication {
                function: Variable {
                 identifier: "flip",
                 position: (421, 9),
                },
                arguments: [
                 Variable {
                  identifier: "concatMap",
                  position: (421, 14),
                 },
                 Variable {
                  identifier: "fqdns",
                  position: (421, 24),
                 },
                 Function {
                  argument: Some(
                   "fqdn",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "d  ",
                       position: (422, 8),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "dataDir",
                        position: (422, 13),
                       },
                      },
                      Raw {
                       content: "/etc/",
                       position: (422, 21),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "fqdn",
                        position: (422, 28),
                       },
                      },
                      Raw {
                       content: "       0700 ",
                       position: (422, 33),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "user",
                        position: (422, 47),
                       },
                      },
                      Raw {
                       content: " ",
                       position: (422, 52),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "group",
                        position: (422, 55),
                       },
                      },
                      Raw {
                       content: " - -",
                       position: (422, 61),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "d  ",
                       position: (423, 8),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "dataDir",
                        position: (423, 13),
                       },
                      },
                      Raw {
                       content: "/list_data/",
                       position: (423, 21),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "fqdn",
                        position: (423, 34),
                       },
                      },
                      Raw {
                       content: " 0700 ",
                       position: (423, 39),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "user",
                        position: (423, 47),
                       },
                      },
                      Raw {
                       content: " ",
                       position: (423, 52),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "group",
                        position: (423, 55),
                       },
                      },
                      Raw {
                       content: " - -",
                       position: (423, 61),
                      },
                     ],
                    },
                   ],
                   position: (421, 37),
                  },
                  position: (421, 31),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "concatLists",
                 position: (428, 9),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "flip",
                   position: (428, 22),
                  },
                  arguments: [
                   Variable {
                    identifier: "mapAttrsToList",
                    position: (428, 27),
                   },
                   Variable {
                    identifier: "enabledFiles",
                    position: (428, 42),
                   },
                   Function {
                    argument: Some(
                     "k",
                    ),
                    arguments: FunctionArguments {
                     arguments: [],
                     ellipsis: false,
                    },
                    definition: Function {
                     argument: Some(
                      "v",
                     ),
                     arguments: FunctionArguments {
                      arguments: [],
                      ellipsis: false,
                     },
                     definition: List {
                      elements: [
                       String {
                        parts: [
                         Raw {
                          content: "R ",
                          position: (431, 8),
                         },
                         Expression {
                          expression: Variable {
                           identifier: "dataDir",
                           position: (431, 12),
                          },
                         },
                         Raw {
                          content: "/",
                          position: (431, 20),
                         },
                         Expression {
                          expression: Variable {
                           identifier: "k",
                           position: (431, 23),
                          },
                         },
                         Raw {
                          content: "              -    -       -        - -",
                          position: (431, 25),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "C ",
                          position: (432, 8),
                         },
                         Expression {
                          expression: Variable {
                           identifier: "dataDir",
                           position: (432, 12),
                          },
                         },
                         Raw {
                          content: "/",
                          position: (432, 20),
                         },
                         Expression {
                          expression: Variable {
                           identifier: "k",
                           position: (432, 23),
                          },
                         },
                         Raw {
                          content: "              0700 ",
                          position: (432, 25),
                         },
                         Expression {
                          expression: Variable {
                           identifier: "user",
                           position: (432, 46),
                          },
                         },
                         Raw {
                          content: "  ",
                          position: (432, 51),
                         },
                         Expression {
                          expression: Variable {
                           identifier: "group",
                           position: (432, 55),
                          },
                         },
                         Raw {
                          content: " - ",
                          position: (432, 61),
                         },
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "v",
                            position: (432, 66),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "source",
                              position: (432, 68),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                        ],
                       },
                      ],
                      position: (428, 62),
                     },
                     position: (428, 59),
                    },
                    position: (428, 56),
                   },
                  ],
                 },
                ],
               },
              ],
              position: (428, 5),
             },
            ],
            position: (421, 5),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (435, 5),
             },
             Raw {
              content: "services",
              position: (435, 13),
             },
             Raw {
              content: "sympa",
              position: (435, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (436, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Sympa mailing list manager",
                 position: (436, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wantedBy",
                 position: (438, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "multi-user.target",
                   position: (438, 21),
                  },
                 ],
                },
               ],
               position: (438, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "after",
                 position: (439, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "network-online.target",
                   position: (439, 18),
                  },
                 ],
                },
               ],
               position: (439, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wants",
                 position: (440, 7),
                },
               ],
              },
              Variable {
               identifier: "sympaSubServices",
               position: (440, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "before",
                 position: (441, 7),
                },
               ],
              },
              Variable {
               identifier: "sympaSubServices",
               position: (441, 16),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (442, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "sympaServiceConfig",
                position: (442, 23),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "sympa_msg",
                   position: (442, 43),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "preStart",
                 position: (444, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "umask 0077\n\ncp -f ",
                 position: (445, 1),
                },
                Expression {
                 expression: Variable {
                  identifier: "mainConfig",
                  position: (447, 17),
                 },
                },
                Raw {
                 content: " ",
                 position: (447, 28),
                },
                Expression {
                 expression: Variable {
                  identifier: "dataDir",
                  position: (447, 31),
                 },
                },
                Raw {
                 content: "/etc/sympa.conf\n",
                 position: (447, 39),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "optionalString",
                   position: (448, 11),
                  },
                  arguments: [
                   BinaryOperation {
                    operator: NotEqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (448, 27),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "database",
                         position: (448, 31),
                        },
                        Raw {
                         content: "passwordFile",
                         position: (448, 40),
                        },
                       ],
                      },
                      default: None,
                     },
                     Variable {
                      identifier: "null",
                      position: (448, 56),
                     },
                    ],
                    position: (448, 53),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "chmod u+w ",
                      position: (449, 1),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "dataDir",
                       position: (449, 23),
                      },
                     },
                     Raw {
                      content: "/etc/sympa.conf\necho -n \"db_passwd \" >> ",
                      position: (449, 31),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "dataDir",
                       position: (450, 37),
                      },
                     },
                     Raw {
                      content: "/etc/sympa.conf\ncat ",
                      position: (450, 45),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (451, 17),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "database",
                          position: (451, 21),
                         },
                         Raw {
                          content: "passwordFile",
                          position: (451, 30),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: " >> ",
                      position: (451, 43),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "dataDir",
                       position: (451, 49),
                      },
                     },
                     Raw {
                      content: "/etc/sympa.conf\n",
                      position: (451, 57),
                     },
                    ],
                   },
                  ],
                 },
                },
                Raw {
                 content: "\n\n",
                 position: (452, 12),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "optionalString",
                   position: (454, 11),
                  },
                  arguments: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (454, 27),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "mta",
                         position: (454, 31),
                        },
                        Raw {
                         content: "type",
                         position: (454, 35),
                        },
                       ],
                      },
                      default: None,
                     },
                     String {
                      parts: [
                       Raw {
                        content: "postfix",
                        position: (454, 44),
                       },
                      ],
                     },
                    ],
                    position: (454, 40),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "",
                      position: (455, 1),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (455, 13),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "postfix",
                          position: (455, 18),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/bin/postmap hash:",
                      position: (455, 26),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "dataDir",
                       position: (455, 46),
                      },
                     },
                     Raw {
                      content: "/virtual.sympa\n",
                      position: (455, 54),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (456, 13),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "postfix",
                          position: (456, 18),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/bin/postmap hash:",
                      position: (456, 26),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "dataDir",
                       position: (456, 46),
                      },
                     },
                     Raw {
                      content: "/transport.sympa\n",
                      position: (456, 54),
                     },
                    ],
                   },
                  ],
                 },
                },
                Raw {
                 content: "\n",
                 position: (457, 12),
                },
                Expression {
                 expression: Variable {
                  identifier: "pkg",
                  position: (458, 11),
                 },
                },
                Raw {
                 content: "/bin/sympa_newaliases.pl\n",
                 position: (458, 15),
                },
                Expression {
                 expression: Variable {
                  identifier: "pkg",
                  position: (459, 11),
                 },
                },
                Raw {
                 content: "/bin/sympa.pl --health_check\n",
                 position: (459, 15),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (435, 30),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (462, 5),
             },
             Raw {
              content: "services",
              position: (462, 13),
             },
             Raw {
              content: "sympa-archive",
              position: (462, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (463, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Sympa mailing list manager (archiving)",
                 position: (463, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "bindsTo",
                 position: (464, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "sympa.service",
                   position: (464, 20),
                  },
                 ],
                },
               ],
               position: (464, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (465, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "sympaServiceConfig",
                position: (465, 23),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "archived",
                   position: (465, 43),
                  },
                 ],
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (462, 38),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (467, 5),
             },
             Raw {
              content: "services",
              position: (467, 13),
             },
             Raw {
              content: "sympa-bounce",
              position: (467, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (468, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Sympa mailing list manager (bounce processing)",
                 position: (468, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "bindsTo",
                 position: (469, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "sympa.service",
                   position: (469, 20),
                  },
                 ],
                },
               ],
               position: (469, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (470, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "sympaServiceConfig",
                position: (470, 23),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "bounced",
                   position: (470, 43),
                  },
                 ],
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (467, 37),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (472, 5),
             },
             Raw {
              content: "services",
              position: (472, 13),
             },
             Raw {
              content: "sympa-bulk",
              position: (472, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (473, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Sympa mailing list manager (message distribution)",
                 position: (473, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "bindsTo",
                 position: (474, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "sympa.service",
                   position: (474, 20),
                  },
                 ],
                },
               ],
               position: (474, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (475, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "sympaServiceConfig",
                position: (475, 23),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "bulk",
                   position: (475, 43),
                  },
                 ],
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (472, 35),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (477, 5),
             },
             Raw {
              content: "services",
              position: (477, 13),
             },
             Raw {
              content: "sympa-task",
              position: (477, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (478, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Sympa mailing list manager (task management)",
                 position: (478, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "bindsTo",
                 position: (479, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "sympa.service",
                   position: (479, 20),
                  },
                 ],
                },
               ],
               position: (479, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (480, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "sympaServiceConfig",
                position: (480, 23),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "task_manager",
                   position: (480, 43),
                  },
                 ],
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (477, 35),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (483, 5),
             },
             Raw {
              content: "services",
              position: (483, 13),
             },
             Raw {
              content: "wwsympa",
              position: (483, 22),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (483, 32),
            },
            arguments: [
             Variable {
              identifier: "usingNginx",
              position: (483, 37),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "wantedBy",
                   position: (484, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "multi-user.target",
                     position: (484, 21),
                    },
                   ],
                  },
                 ],
                 position: (484, 18),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "after",
                   position: (485, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "sympa.service",
                     position: (485, 18),
                    },
                   ],
                  },
                 ],
                 position: (485, 15),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "serviceConfig",
                   position: (486, 7),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Update,
                 operands: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "Type",
                        position: (487, 9),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "forking",
                        position: (487, 17),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "PIDFile",
                        position: (488, 9),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "/run/sympa/wwsympa.pid",
                        position: (488, 20),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "Restart",
                        position: (489, 9),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "always",
                        position: (489, 20),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "ExecStart",
                        position: (490, 9),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "pkgs",
                          position: (490, 25),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "spawn_fcgi",
                            position: (490, 30),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/bin/spawn-fcgi \\\n          -u ",
                        position: (490, 41),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "user",
                         position: (491, 16),
                        },
                       },
                       Raw {
                        content: " \\\n          -g ",
                        position: (491, 21),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "group",
                         position: (492, 16),
                        },
                       },
                       Raw {
                        content: " \\\n          -U nginx \\\n          -M 0600 \\\n          -F ",
                        position: (492, 22),
                       },
                       Expression {
                        expression: FunctionApplication {
                         function: Variable {
                          identifier: "toString",
                          position: (495, 16),
                         },
                         arguments: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (495, 25),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "web",
                              position: (495, 29),
                             },
                             Raw {
                              content: "fcgiProcs",
                              position: (495, 33),
                             },
                            ],
                           },
                           default: None,
                          },
                         ],
                        },
                       },
                       Raw {
                        content: " \\\n          -P /run/sympa/wwsympa.pid \\\n          -s /run/sympa/wwsympa.socket \\\n          -- ",
                        position: (495, 43),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "pkg",
                         position: (498, 16),
                        },
                       },
                       Raw {
                        content: "/lib/sympa/cgi/wwsympa.fcgi\n        ",
                        position: (498, 20),
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (486, 23),
                  },
                  Variable {
                   identifier: "commonServiceConfig",
                   position: (501, 12),
                  },
                 ],
                 position: (501, 9),
                },
               ),
              ],
              recursive: false,
              position: (483, 48),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (504, 5),
             },
             Raw {
              content: "nginx",
              position: (504, 14),
             },
             Raw {
              content: "enable",
              position: (504, 20),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (504, 29),
            },
            arguments: [
             Variable {
              identifier: "usingNginx",
              position: (504, 34),
             },
             Variable {
              identifier: "true",
              position: (504, 45),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (505, 5),
             },
             Raw {
              content: "nginx",
              position: (505, 14),
             },
             Raw {
              content: "virtualHosts",
              position: (505, 20),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (505, 35),
            },
            arguments: [
             Variable {
              identifier: "usingNginx",
              position: (505, 40),
             },
             LetIn {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "vHosts",
                   position: (506, 7),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "unique",
                  position: (506, 16),
                 },
                 arguments: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "remove",
                    position: (506, 24),
                   },
                   arguments: [
                    Variable {
                     identifier: "null",
                     position: (506, 31),
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "mapAttrsToList",
                      position: (506, 37),
                     },
                     arguments: [
                      Function {
                       argument: Some(
                        "_k",
                       ),
                       arguments: FunctionArguments {
                        arguments: [],
                        ellipsis: false,
                       },
                       definition: Function {
                        argument: Some(
                         "v",
                        ),
                        arguments: FunctionArguments {
                         arguments: [],
                         ellipsis: false,
                        },
                        definition: PropertyAccess {
                         expression: Variable {
                          identifier: "v",
                          position: (506, 60),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "webHost",
                            position: (506, 62),
                           },
                          ],
                         },
                         default: None,
                        },
                        position: (506, 57),
                       },
                       position: (506, 53),
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (506, 71),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "domains",
                          position: (506, 75),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   ],
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "hostLocations",
                   position: (507, 7),
                  },
                 ],
                },
                Function {
                 argument: Some(
                  "host",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: FunctionApplication {
                  function: Variable {
                   identifier: "map",
                   position: (507, 29),
                  },
                  arguments: [
                   Function {
                    argument: Some(
                     "v",
                    ),
                    arguments: FunctionArguments {
                     arguments: [],
                     ellipsis: false,
                    },
                    definition: PropertyAccess {
                     expression: Variable {
                      identifier: "v",
                      position: (507, 37),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "webLocation",
                        position: (507, 39),
                       },
                      ],
                     },
                     default: None,
                    },
                    position: (507, 34),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "filter",
                     position: (507, 53),
                    },
                    arguments: [
                     Function {
                      argument: Some(
                       "v",
                      ),
                      arguments: FunctionArguments {
                       arguments: [],
                       ellipsis: false,
                      },
                      definition: BinaryOperation {
                       operator: EqualTo,
                       operands: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "v",
                          position: (507, 64),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "webHost",
                            position: (507, 66),
                           },
                          ],
                         },
                         default: None,
                        },
                        Variable {
                         identifier: "host",
                         position: (507, 77),
                        },
                       ],
                       position: (507, 74),
                      },
                      position: (507, 61),
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "attrValues",
                       position: (507, 84),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (507, 95),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "domains",
                           position: (507, 99),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    ],
                   },
                  ],
                 },
                 position: (507, 23),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "httpsOpts",
                   position: (508, 7),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "optionalAttrs",
                  position: (508, 19),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (508, 33),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "web",
                      position: (508, 37),
                     },
                     Raw {
                      content: "https",
                      position: (508, 41),
                     },
                    ],
                   },
                   default: None,
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "forceSSL",
                        position: (508, 49),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "mkDefault",
                       position: (508, 60),
                      },
                      arguments: [
                       Variable {
                        identifier: "true",
                        position: (508, 70),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "enableACME",
                        position: (508, 76),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "mkDefault",
                       position: (508, 89),
                      },
                      arguments: [
                       Variable {
                        identifier: "true",
                        position: (508, 99),
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (508, 47),
                  },
                 ],
                },
               ),
              ],
              target: FunctionApplication {
               function: Variable {
                identifier: "genAttrs",
                position: (510, 5),
               },
               arguments: [
                Variable {
                 identifier: "vHosts",
                 position: (510, 14),
                },
                Function {
                 argument: Some(
                  "host",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: BinaryOperation {
                  operator: Update,
                  operands: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "locations",
                         position: (511, 7),
                        },
                       ],
                      },
                      BinaryOperation {
                       operator: Update,
                       operands: [
                        FunctionApplication {
                         function: Variable {
                          identifier: "genAttrs",
                          position: (511, 19),
                         },
                         arguments: [
                          FunctionApplication {
                           function: Variable {
                            identifier: "hostLocations",
                            position: (511, 29),
                           },
                           arguments: [
                            Variable {
                             identifier: "host",
                             position: (511, 43),
                            },
                           ],
                          },
                          Function {
                           argument: Some(
                            "loc",
                           ),
                           arguments: FunctionArguments {
                            arguments: [],
                            ellipsis: false,
                           },
                           definition: Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "extraConfig",
                                 position: (512, 9),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "include ",
                                 position: (513, 1),
                                },
                                Expression {
                                 expression: PropertyAccess {
                                  expression: Variable {
                                   identifier: "config",
                                   position: (513, 21),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "services",
                                     position: (513, 28),
                                    },
                                    Raw {
                                     content: "nginx",
                                     position: (513, 37),
                                    },
                                    Raw {
                                     content: "package",
                                     position: (513, 43),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                },
                                Raw {
                                 content: "/conf/fastcgi_params;\n\nfastcgi_pass unix:/run/sympa/wwsympa.socket;\n",
                                 position: (513, 51),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (511, 55),
                           },
                           position: (511, 50),
                          },
                         ],
                        },
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Expression {
                              expression: String {
                               parts: [
                                Raw {
                                 content: "/static-sympa/",
                                 position: (518, 10),
                                },
                               ],
                              },
                             },
                             Raw {
                              content: "alias",
                              position: (518, 26),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Expression {
                              expression: Variable {
                               identifier: "dataDir",
                               position: (518, 37),
                              },
                             },
                             Raw {
                              content: "/static_content/",
                              position: (518, 45),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (517, 13),
                        },
                       ],
                       position: (517, 10),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (510, 28),
                   },
                   Variable {
                    identifier: "httpsOpts",
                    position: (520, 10),
                   },
                  ],
                  position: (520, 7),
                 },
                 position: (510, 22),
                },
               ],
              },
              position: (505, 52),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (522, 5),
             },
             Raw {
              content: "postfix",
              position: (522, 14),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (522, 24),
            },
            arguments: [
             BinaryOperation {
              operator: EqualTo,
              operands: [
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (522, 30),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "mta",
                   position: (522, 34),
                  },
                  Raw {
                   content: "type",
                   position: (522, 38),
                  },
                 ],
                },
                default: None,
               },
               String {
                parts: [
                 Raw {
                  content: "postfix",
                  position: (522, 47),
                 },
                ],
               },
              ],
              position: (522, 43),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "enable",
                   position: (523, 7),
                  },
                 ],
                },
                Variable {
                 identifier: "true",
                 position: (523, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "recipientDelimiter",
                   position: (524, 7),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "+",
                   position: (524, 29),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "config",
                   position: (525, 7),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "virtual_alias_maps",
                      position: (526, 9),
                     },
                    ],
                   },
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "hash:",
                        position: (526, 33),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "dataDir",
                         position: (526, 40),
                        },
                       },
                       Raw {
                        content: "/virtual.sympa",
                        position: (526, 48),
                       },
                      ],
                     },
                    ],
                    position: (526, 30),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "virtual_mailbox_maps",
                      position: (527, 9),
                     },
                    ],
                   },
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "hash:",
                        position: (528, 12),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "dataDir",
                         position: (528, 19),
                        },
                       },
                       Raw {
                        content: "/transport.sympa",
                        position: (528, 27),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "hash:",
                        position: (529, 12),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "dataDir",
                         position: (529, 19),
                        },
                       },
                       Raw {
                        content: "/sympa_transport",
                        position: (529, 27),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "hash:",
                        position: (530, 12),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "dataDir",
                         position: (530, 19),
                        },
                       },
                       Raw {
                        content: "/virtual.sympa",
                        position: (530, 27),
                       },
                      ],
                     },
                    ],
                    position: (527, 32),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "virtual_mailbox_domains",
                      position: (532, 9),
                     },
                    ],
                   },
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "hash:",
                        position: (532, 38),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "dataDir",
                         position: (532, 45),
                        },
                       },
                       Raw {
                        content: "/transport.sympa",
                        position: (532, 53),
                       },
                      ],
                     },
                    ],
                    position: (532, 35),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "transport_maps",
                      position: (533, 9),
                     },
                    ],
                   },
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "hash:",
                        position: (534, 12),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "dataDir",
                         position: (534, 19),
                        },
                       },
                       Raw {
                        content: "/transport.sympa",
                        position: (534, 27),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "hash:",
                        position: (535, 12),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "dataDir",
                         position: (535, 19),
                        },
                       },
                       Raw {
                        content: "/sympa_transport",
                        position: (535, 27),
                       },
                      ],
                     },
                    ],
                    position: (533, 26),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (525, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "masterConfig",
                   position: (538, 7),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "sympa",
                         position: (539, 10),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (540, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "unix",
                         position: (540, 19),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "privileged",
                         position: (541, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "true",
                       position: (541, 24),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "chroot",
                         position: (542, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (542, 20),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "command",
                         position: (543, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "pipe",
                         position: (543, 22),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "args",
                         position: (544, 11),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "flags=hqRu",
                           position: (545, 14),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "user=",
                           position: (546, 14),
                          },
                          Expression {
                           expression: Variable {
                            identifier: "user",
                            position: (546, 21),
                           },
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "argv=",
                           position: (547, 14),
                          },
                          Expression {
                           expression: Variable {
                            identifier: "pkg",
                            position: (547, 21),
                           },
                          },
                          Raw {
                           content: "/libexec/queue",
                           position: (547, 25),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "${nexthop}",
                           position: (548, 14),
                          },
                         ],
                        },
                       ],
                       position: (544, 18),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (539, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "sympabounce",
                         position: (551, 10),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (552, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "unix",
                         position: (552, 19),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "privileged",
                         position: (553, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "true",
                       position: (553, 24),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "chroot",
                         position: (554, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (554, 20),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "command",
                         position: (555, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "pipe",
                         position: (555, 22),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "args",
                         position: (556, 11),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "flags=hqRu",
                           position: (557, 14),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "user=",
                           position: (558, 14),
                          },
                          Expression {
                           expression: Variable {
                            identifier: "user",
                            position: (558, 21),
                           },
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "argv=",
                           position: (559, 14),
                          },
                          Expression {
                           expression: Variable {
                            identifier: "pkg",
                            position: (559, 21),
                           },
                          },
                          Raw {
                           content: "/libexec/bouncequeue",
                           position: (559, 25),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "${nexthop}",
                           position: (560, 14),
                          },
                         ],
                        },
                       ],
                       position: (556, 18),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (551, 25),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (538, 22),
                },
               ),
              ],
              recursive: false,
              position: (522, 57),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (566, 5),
             },
             Raw {
              content: "mysql",
              position: (566, 14),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "optionalAttrs",
             position: (566, 22),
            },
            arguments: [
             Variable {
              identifier: "mysqlLocal",
              position: (566, 36),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "enable",
                   position: (567, 7),
                  },
                 ],
                },
                Variable {
                 identifier: "true",
                 position: (567, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "package",
                   position: (568, 7),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mkDefault",
                  position: (568, 17),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (568, 27),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "mariadb",
                      position: (568, 32),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "ensureDatabases",
                   position: (569, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (569, 27),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "database",
                      position: (569, 31),
                     },
                     Raw {
                      content: "name",
                      position: (569, 40),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (569, 25),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "ensureUsers",
                   position: (570, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "name",
                        position: (571, 11),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (571, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "database",
                         position: (571, 22),
                        },
                        Raw {
                         content: "user",
                         position: (571, 31),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "ensurePermissions",
                        position: (572, 11),
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Expression {
                           expression: String {
                            parts: [
                             Expression {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "cfg",
                                position: (572, 36),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "database",
                                  position: (572, 40),
                                 },
                                 Raw {
                                  content: "name",
                                  position: (572, 49),
                                 },
                                ],
                               },
                               default: None,
                              },
                             },
                             Raw {
                              content: ".*",
                              position: (572, 54),
                             },
                            ],
                           },
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "ALL PRIVILEGES",
                           position: (572, 61),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (572, 31),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (571, 9),
                  },
                 ],
                 position: (570, 21),
                },
               ),
              ],
              recursive: false,
              position: (566, 47),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (577, 5),
             },
             Raw {
              content: "postgresql",
              position: (577, 14),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "optionalAttrs",
             position: (577, 27),
            },
            arguments: [
             Variable {
              identifier: "pgsqlLocal",
              position: (577, 41),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "enable",
                   position: (578, 7),
                  },
                 ],
                },
                Variable {
                 identifier: "true",
                 position: (578, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "ensureDatabases",
                   position: (579, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (579, 27),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "database",
                      position: (579, 31),
                     },
                     Raw {
                      content: "name",
                      position: (579, 40),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (579, 25),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "ensureUsers",
                   position: (580, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "name",
                        position: (581, 11),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (581, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "database",
                         position: (581, 22),
                        },
                        Raw {
                         content: "user",
                         position: (581, 31),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "ensurePermissions",
                        position: (582, 11),
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Expression {
                           expression: String {
                            parts: [
                             Raw {
                              content: "DATABASE ",
                              position: (582, 34),
                             },
                             Expression {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "cfg",
                                position: (582, 45),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "database",
                                  position: (582, 49),
                                 },
                                 Raw {
                                  content: "name",
                                  position: (582, 58),
                                 },
                                ],
                               },
                               default: None,
                              },
                             },
                            ],
                           },
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "ALL PRIVILEGES",
                           position: (582, 68),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (582, 31),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (581, 9),
                  },
                 ],
                 position: (580, 21),
                },
               ),
              ],
              recursive: false,
              position: (577, 52),
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (330, 28),
        },
       ],
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "meta",
         position: (589, 3),
        },
        Raw {
         content: "maintainers",
         position: (589, 8),
        },
       ],
      },
      With {
       expression: Variable {
        identifier: "maintainers",
        position: (589, 27),
       },
       target: List {
        elements: [
         Variable {
          identifier: "mmilata",
          position: (589, 42),
         },
         Variable {
          identifier: "sorki",
          position: (589, 50),
         },
        ],
        position: (589, 40),
       },
       position: (589, 22),
      },
     ),
    ],
    recursive: false,
    position: (78, 1),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}