---
Function {
 argument: Destructured {
  identifier: None,
  arguments: [
   DestructuredArgument {
    identifier: "config",
    default: None,
   },
   DestructuredArgument {
    identifier: "lib",
    default: None,
   },
   DestructuredArgument {
    identifier: "pkgs",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (3, 6),
  },
  target: LetIn {
   bindings: [
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "cfg",
        position: (6, 3),
       },
      ],
     },
     to: PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (6, 9),
      },
      attribute_path: AttributePath {
       parts: [
        Raw {
         content: "services",
         position: (6, 16),
        },
        Raw {
         content: "sympa",
         position: (6, 25),
        },
       ],
      },
      default: None,
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "dataDir",
        position: (7, 3),
       },
      ],
     },
     to: String {
      parts: [
       Raw {
        content: "/var/lib/sympa",
        position: (7, 14),
       },
      ],
      position: (7, 13),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "user",
        position: (8, 3),
       },
      ],
     },
     to: String {
      parts: [
       Raw {
        content: "sympa",
        position: (8, 11),
       },
      ],
      position: (8, 10),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "group",
        position: (9, 3),
       },
      ],
     },
     to: String {
      parts: [
       Raw {
        content: "sympa",
        position: (9, 12),
       },
      ],
      position: (9, 11),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "pkg",
        position: (10, 3),
       },
      ],
     },
     to: PropertyAccess {
      expression: Variable {
       identifier: "pkgs",
       position: (10, 9),
      },
      attribute_path: AttributePath {
       parts: [
        Raw {
         content: "sympa",
         position: (10, 14),
        },
       ],
      },
      default: None,
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "fqdns",
        position: (11, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "attrNames",
       position: (11, 11),
      },
      arguments: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (11, 21),
        },
        attribute_path: AttributePath {
         parts: [
          Raw {
           content: "domains",
           position: (11, 25),
          },
         ],
        },
        default: None,
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "usingNginx",
        position: (12, 3),
       },
      ],
     },
     to: BinaryOperation {
      operator: LogicalAnd,
      operands: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (12, 16),
        },
        attribute_path: AttributePath {
         parts: [
          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 {
           parts: [
            Raw {
             content: "web",
             position: (12, 38),
            },
            Raw {
             content: "server",
             position: (12, 42),
            },
           ],
          },
          default: None,
         },
         String {
          parts: [
           Raw {
            content: "nginx",
            position: (12, 53),
           },
          ],
          position: (12, 52),
         },
        ],
        position: (12, 49),
       },
      ],
      position: (12, 31),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mysqlLocal",
        position: (13, 3),
       },
      ],
     },
     to: BinaryOperation {
      operator: LogicalAnd,
      operands: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (13, 16),
        },
        attribute_path: AttributePath {
         parts: [
          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 {
           parts: [
            Raw {
             content: "database",
             position: (13, 50),
            },
            Raw {
             content: "type",
             position: (13, 59),
            },
           ],
          },
          default: None,
         },
         String {
          parts: [
           Raw {
            content: "MySQL",
            position: (13, 68),
           },
          ],
          position: (13, 67),
         },
        ],
        position: (13, 64),
       },
      ],
      position: (13, 43),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "pgsqlLocal",
        position: (14, 3),
       },
      ],
     },
     to: BinaryOperation {
      operator: LogicalAnd,
      operands: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (14, 16),
        },
        attribute_path: AttributePath {
         parts: [
          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 {
           parts: [
            Raw {
             content: "database",
             position: (14, 50),
            },
            Raw {
             content: "type",
             position: (14, 59),
            },
           ],
          },
          default: None,
         },
         String {
          parts: [
           Raw {
            content: "PostgreSQL",
            position: (14, 68),
           },
          ],
          position: (14, 67),
         },
        ],
        position: (14, 64),
       },
      ],
      position: (14, 43),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "sympaSubServices",
        position: (16, 3),
       },
      ],
     },
     to: List {
      elements: [
       String {
        parts: [
         Raw {
          content: "sympa-archive.service",
          position: (17, 6),
         },
        ],
        position: (17, 5),
       },
       String {
        parts: [
         Raw {
          content: "sympa-bounce.service",
          position: (18, 6),
         },
        ],
        position: (18, 5),
       },
       String {
        parts: [
         Raw {
          content: "sympa-bulk.service",
          position: (19, 6),
         },
        ],
        position: (19, 5),
       },
       String {
        parts: [
         Raw {
          content: "sympa-task.service",
          position: (20, 6),
         },
        ],
        position: (20, 5),
       },
      ],
      position: (16, 22),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "commonServiceConfig",
        position: (24, 3),
       },
      ],
     },
     to: Map {
      bindings: [
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "StateDirectory",
           position: (25, 5),
          },
         ],
        },
        to: String {
         parts: [
          Raw {
           content: "sympa",
           position: (25, 23),
          },
         ],
         position: (25, 22),
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "ProtectHome",
           position: (26, 5),
          },
         ],
        },
        to: Variable {
         identifier: "true",
         position: (26, 19),
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "ProtectSystem",
           position: (27, 5),
          },
         ],
        },
        to: String {
         parts: [
          Raw {
           content: "full",
           position: (27, 22),
          },
         ],
         position: (27, 21),
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "ProtectControlGroups",
           position: (28, 5),
          },
         ],
        },
        to: Variable {
         identifier: "true",
         position: (28, 28),
        },
       },
      ],
      recursive: false,
      position: (24, 25),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "sympaServiceConfig",
        position: (32, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "srv",
      },
      definition: BinaryOperation {
       operator: Update,
       operands: [
        Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "Type",
              position: (33, 5),
             },
            ],
           },
           to: String {
            parts: [
             Raw {
              content: "simple",
              position: (33, 13),
             },
            ],
            position: (33, 12),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "Restart",
              position: (34, 5),
             },
            ],
           },
           to: String {
            parts: [
             Raw {
              content: "always",
              position: (34, 16),
             },
            ],
            position: (34, 15),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "ExecStart",
              position: (35, 5),
             },
            ],
           },
           to: 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),
             },
            ],
            position: (35, 17),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "PIDFile",
              position: (36, 5),
             },
            ],
           },
           to: String {
            parts: [
             Raw {
              content: "/run/sympa/",
              position: (36, 16),
             },
             Expression {
              expression: Variable {
               identifier: "srv",
               position: (36, 29),
              },
             },
             Raw {
              content: ".pid",
              position: (36, 33),
             },
            ],
            position: (36, 15),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "User",
              position: (37, 5),
             },
            ],
           },
           to: Variable {
            identifier: "user",
            position: (37, 12),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "Group",
              position: (38, 5),
             },
            ],
           },
           to: Variable {
            identifier: "group",
            position: (38, 13),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "StandardError",
              position: (41, 5),
             },
            ],
           },
           to: String {
            parts: [
             Raw {
              content: "null",
              position: (41, 22),
             },
            ],
            position: (41, 21),
           },
          },
         ],
         recursive: false,
         position: (32, 29),
        },
        Variable {
         identifier: "commonServiceConfig",
         position: (42, 8),
        },
       ],
       position: (42, 5),
      },
      position: (32, 24),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "configVal",
        position: (44, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "value",
      },
      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),
          },
         ],
         position: (46, 21),
        },
        else_: String {
         parts: [
          Raw {
           content: "off",
           position: (46, 32),
          },
         ],
         position: (46, 31),
        },
        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),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "configGenerator",
        position: (48, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "c",
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "concatStrings",
        position: (48, 24),
       },
       arguments: [
        Parentheses {
         expression: FunctionApplication {
          function: Variable {
           identifier: "flip",
           position: (48, 39),
          },
          arguments: [
           Variable {
            identifier: "mapAttrsToList",
            position: (48, 44),
           },
           Variable {
            identifier: "c",
            position: (48, 59),
           },
           Parentheses {
            expression: Function {
             argument: Simple {
              identifier: "key",
             },
             definition: Function {
              argument: Simple {
               identifier: "val",
              },
              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, 72),
              },
              position: (48, 67),
             },
             position: (48, 62),
            },
            position: (48, 61),
           },
          ],
         },
         position: (48, 38),
        },
       ],
      },
      position: (48, 21),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "mainConfig",
        position: (50, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (50, 16),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "writeText",
          position: (50, 21),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "sympa.conf",
          position: (50, 32),
         },
        ],
        position: (50, 31),
       },
       Parentheses {
        expression: FunctionApplication {
         function: Variable {
          identifier: "configGenerator",
          position: (50, 45),
         },
         arguments: [
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (50, 61),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "settings",
              position: (50, 65),
             },
            ],
           },
           default: None,
          },
         ],
        },
        position: (50, 44),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "robotConfig",
        position: (51, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "fqdn",
      },
      definition: Function {
       argument: Simple {
        identifier: "domain",
       },
       definition: FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (51, 31),
         },
         attribute_path: AttributePath {
          parts: [
           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),
           },
          ],
          position: (51, 46),
         },
         Parentheses {
          expression: FunctionApplication {
           function: Variable {
            identifier: "configGenerator",
            position: (51, 68),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "domain",
              position: (51, 84),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "settings",
                position: (51, 91),
               },
              ],
             },
             default: None,
            },
           ],
          },
          position: (51, 67),
         },
        ],
       },
       position: (51, 23),
      },
      position: (51, 17),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "transport",
        position: (53, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (53, 15),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "writeText",
          position: (53, 20),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "transport.sympa",
          position: (53, 31),
         },
        ],
        position: (53, 30),
       },
       Parentheses {
        expression: FunctionApplication {
         function: Variable {
          identifier: "concatStringsSep",
          position: (53, 49),
         },
         arguments: [
          String {
           parts: [
            Raw {
             content: "\n",
             position: (53, 67),
            },
           ],
           position: (53, 66),
          },
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "flip",
             position: (53, 72),
            },
            arguments: [
             Variable {
              identifier: "map",
              position: (53, 77),
             },
             Variable {
              identifier: "fqdns",
              position: (53, 81),
             },
             Parentheses {
              expression: Function {
               argument: Simple {
                identifier: "domain",
               },
               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, 96),
               },
               position: (53, 88),
              },
              position: (53, 87),
             },
            ],
           },
           position: (53, 71),
          },
         ],
        },
        position: (53, 48),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "virtual",
        position: (61, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (61, 13),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "writeText",
          position: (61, 18),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "virtual.sympa",
          position: (61, 29),
         },
        ],
        position: (61, 28),
       },
       Parentheses {
        expression: FunctionApplication {
         function: Variable {
          identifier: "concatStringsSep",
          position: (61, 45),
         },
         arguments: [
          String {
           parts: [
            Raw {
             content: "\n",
             position: (61, 63),
            },
           ],
           position: (61, 62),
          },
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "flip",
             position: (61, 68),
            },
            arguments: [
             Variable {
              identifier: "map",
              position: (61, 73),
             },
             Variable {
              identifier: "fqdns",
              position: (61, 77),
             },
             Parentheses {
              expression: Function {
               argument: Simple {
                identifier: "domain",
               },
               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, 92),
               },
               position: (61, 84),
              },
              position: (61, 83),
             },
            ],
           },
           position: (61, 67),
          },
         ],
        },
        position: (61, 44),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "listAliases",
        position: (66, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (66, 17),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "writeText",
          position: (66, 22),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "list_aliases.tt2",
          position: (66, 33),
         },
        ],
        position: (66, 32),
       },
       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),
         },
        ],
        position: (66, 51),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "enabledFiles",
        position: (76, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "filterAttrs",
       position: (76, 18),
      },
      arguments: [
       Parentheses {
        expression: Function {
         argument: Simple {
          identifier: "n",
         },
         definition: Function {
          argument: Simple {
           identifier: "v",
          },
          definition: PropertyAccess {
           expression: Variable {
            identifier: "v",
            position: (76, 37),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "enable",
              position: (76, 39),
             },
            ],
           },
           default: None,
          },
          position: (76, 34),
         },
         position: (76, 31),
        },
        position: (76, 30),
       },
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (76, 47),
        },
        attribute_path: AttributePath {
         parts: [
          Raw {
           content: "settingsFile",
           position: (76, 51),
          },
         ],
        },
        default: None,
       },
      ],
     },
    },
   ],
   target: Map {
    bindings: [
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "options",
         position: (81, 3),
        },
        Raw {
         content: "services",
         position: (81, 11),
        },
        Raw {
         content: "sympa",
         position: (81, 20),
        },
       ],
      },
      to: With {
       expression: Variable {
        identifier: "types",
        position: (81, 33),
       },
       target: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "enable",
             position: (83, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mkEnableOption",
            position: (83, 14),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "Sympa mailing list manager",
               position: (83, 30),
              },
             ],
             position: (83, 29),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "lang",
             position: (85, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (85, 12),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "type",
                  position: (86, 7),
                 },
                ],
               },
               to: Variable {
                identifier: "str",
                position: (86, 14),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "default",
                  position: (87, 7),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "en_US",
                  position: (87, 18),
                 },
                ],
                position: (87, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "example",
                  position: (88, 7),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "cs",
                  position: (88, 18),
                 },
                ],
                position: (88, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (89, 7),
                 },
                ],
               },
               to: 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),
                 },
                ],
                position: (89, 21),
               },
              },
             ],
             recursive: false,
             position: (85, 21),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "listMasters",
             position: (96, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (96, 19),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "type",
                  position: (97, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "listOf",
                 position: (97, 14),
                },
                arguments: [
                 Variable {
                  identifier: "str",
                  position: (97, 21),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "example",
                  position: (98, 7),
                 },
                ],
               },
               to: List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "postmaster@sympa.example.org",
                    position: (98, 20),
                   },
                  ],
                  position: (98, 19),
                 },
                ],
                position: (98, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (99, 7),
                 },
                ],
               },
               to: 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),
                 },
                ],
                position: (99, 21),
               },
              },
             ],
             recursive: false,
             position: (96, 28),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "mainDomain",
             position: (105, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (105, 18),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "type",
                  position: (106, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "nullOr",
                 position: (106, 14),
                },
                arguments: [
                 Variable {
                  identifier: "str",
                  position: (106, 21),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "default",
                  position: (107, 7),
                 },
                ],
               },
               to: Variable {
                identifier: "null",
                position: (107, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "example",
                  position: (108, 7),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "lists.example.org",
                  position: (108, 18),
                 },
                ],
                position: (108, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (109, 7),
                 },
                ],
               },
               to: 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),
                 },
                ],
                position: (109, 21),
               },
              },
             ],
             recursive: false,
             position: (105, 27),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "domains",
             position: (115, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (115, 15),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "type",
                  position: (116, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "attrsOf",
                 position: (116, 14),
                },
                arguments: [
                 Parentheses {
                  expression: FunctionApplication {
                   function: Variable {
                    identifier: "submodule",
                    position: (116, 23),
                   },
                   arguments: [
                    Parentheses {
                     expression: Function {
                      argument: Destructured {
                       identifier: None,
                       arguments: [
                        DestructuredArgument {
                         identifier: "name",
                         default: None,
                        },
                        DestructuredArgument {
                         identifier: "config",
                         default: None,
                        },
                       ],
                       ellipsis: true,
                      },
                      definition: Map {
                       bindings: [
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "options",
                            position: (117, 9),
                           },
                          ],
                         },
                         to: Map {
                          bindings: [
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "webHost",
                               position: (118, 11),
                              },
                             ],
                            },
                            to: FunctionApplication {
                             function: Variable {
                              identifier: "mkOption",
                              position: (118, 21),
                             },
                             arguments: [
                              Map {
                               bindings: [
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "type",
                                    position: (119, 13),
                                   },
                                  ],
                                 },
                                 to: FunctionApplication {
                                  function: Variable {
                                   identifier: "nullOr",
                                   position: (119, 20),
                                  },
                                  arguments: [
                                   Variable {
                                    identifier: "str",
                                    position: (119, 27),
                                   },
                                  ],
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "default",
                                    position: (120, 13),
                                   },
                                  ],
                                 },
                                 to: Variable {
                                  identifier: "null",
                                  position: (120, 23),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "example",
                                    position: (121, 13),
                                   },
                                  ],
                                 },
                                 to: String {
                                  parts: [
                                   Raw {
                                    content: "archive.example.org",
                                    position: (121, 24),
                                   },
                                  ],
                                  position: (121, 23),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "description",
                                    position: (122, 13),
                                   },
                                  ],
                                 },
                                 to: 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),
                                   },
                                  ],
                                  position: (122, 27),
                                 },
                                },
                               ],
                               recursive: false,
                               position: (118, 30),
                              },
                             ],
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "webLocation",
                               position: (127, 11),
                              },
                             ],
                            },
                            to: FunctionApplication {
                             function: Variable {
                              identifier: "mkOption",
                              position: (127, 25),
                             },
                             arguments: [
                              Map {
                               bindings: [
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "type",
                                    position: (128, 13),
                                   },
                                  ],
                                 },
                                 to: Variable {
                                  identifier: "str",
                                  position: (128, 20),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "default",
                                    position: (129, 13),
                                   },
                                  ],
                                 },
                                 to: String {
                                  parts: [
                                   Raw {
                                    content: "/",
                                    position: (129, 24),
                                   },
                                  ],
                                  position: (129, 23),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "example",
                                    position: (130, 13),
                                   },
                                  ],
                                 },
                                 to: String {
                                  parts: [
                                   Raw {
                                    content: "/sympa",
                                    position: (130, 24),
                                   },
                                  ],
                                  position: (130, 23),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "description",
                                    position: (131, 13),
                                   },
                                  ],
                                 },
                                 to: String {
                                  parts: [
                                   Raw {
                                    content: "URL path part of the web interface.",
                                    position: (131, 28),
                                   },
                                  ],
                                  position: (131, 27),
                                 },
                                },
                               ],
                               recursive: false,
                               position: (127, 34),
                              },
                             ],
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "settings",
                               position: (133, 11),
                              },
                             ],
                            },
                            to: FunctionApplication {
                             function: Variable {
                              identifier: "mkOption",
                              position: (133, 22),
                             },
                             arguments: [
                              Map {
                               bindings: [
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "type",
                                    position: (134, 13),
                                   },
                                  ],
                                 },
                                 to: FunctionApplication {
                                  function: Variable {
                                   identifier: "attrsOf",
                                   position: (134, 20),
                                  },
                                  arguments: [
                                   Parentheses {
                                    expression: 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),
                                      },
                                     ],
                                    },
                                    position: (134, 28),
                                   },
                                  ],
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "default",
                                    position: (135, 13),
                                   },
                                  ],
                                 },
                                 to: Map {
                                  bindings: [],
                                  recursive: false,
                                  position: (135, 23),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "example",
                                    position: (136, 13),
                                   },
                                  ],
                                 },
                                 to: Map {
                                  bindings: [
                                   Binding {
                                    from: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "default_max_list_members",
                                       position: (137, 15),
                                      },
                                     ],
                                    },
                                    to: Int {
                                     value: 3,
                                     position: (137, 42),
                                    },
                                   },
                                  ],
                                  recursive: false,
                                  position: (136, 23),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "description",
                                    position: (139, 13),
                                   },
                                  ],
                                 },
                                 to: 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),
                                   },
                                  ],
                                  position: (139, 27),
                                 },
                                },
                               ],
                               recursive: false,
                               position: (133, 31),
                              },
                             ],
                            },
                           },
                          ],
                          recursive: false,
                          position: (117, 19),
                         },
                        },
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "config",
                            position: (147, 9),
                           },
                           Raw {
                            content: "settings",
                            position: (147, 16),
                           },
                          ],
                         },
                         to: FunctionApplication {
                          function: Variable {
                           identifier: "mkIf",
                           position: (147, 27),
                          },
                          arguments: [
                           Parentheses {
                            expression: BinaryOperation {
                             operator: LogicalAnd,
                             operands: [
                              PropertyAccess {
                               expression: Variable {
                                identifier: "cfg",
                                position: (147, 33),
                               },
                               attribute_path: AttributePath {
                                parts: [
                                 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 {
                                  parts: [
                                   Raw {
                                    content: "webHost",
                                    position: (147, 58),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                Variable {
                                 identifier: "null",
                                 position: (147, 69),
                                },
                               ],
                               position: (147, 66),
                              },
                             ],
                             position: (147, 48),
                            },
                            position: (147, 32),
                           },
                           Map {
                            bindings: [
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "wwsympa_url",
                                 position: (148, 11),
                                },
                               ],
                              },
                              to: 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 {
                                     parts: [
                                      Raw {
                                       content: "webHost",
                                       position: (148, 53),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                  },
                                  Expression {
                                   expression: FunctionApplication {
                                    function: PropertyAccess {
                                     expression: Variable {
                                      identifier: "strings",
                                      position: (148, 63),
                                     },
                                     attribute_path: AttributePath {
                                      parts: [
                                       Raw {
                                        content: "removeSuffix",
                                        position: (148, 71),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                    arguments: [
                                     String {
                                      parts: [
                                       Raw {
                                        content: "/",
                                        position: (148, 85),
                                       },
                                      ],
                                      position: (148, 84),
                                     },
                                     PropertyAccess {
                                      expression: Variable {
                                       identifier: "config",
                                       position: (148, 88),
                                      },
                                      attribute_path: AttributePath {
                                       parts: [
                                        Raw {
                                         content: "webLocation",
                                         position: (148, 95),
                                        },
                                       ],
                                      },
                                      default: None,
                                     },
                                    ],
                                   },
                                  },
                                 ],
                                 position: (148, 35),
                                },
                               ],
                              },
                             },
                            ],
                            recursive: false,
                            position: (147, 75),
                           },
                          ],
                         },
                        },
                       ],
                       recursive: false,
                       position: (116, 57),
                      },
                      position: (116, 34),
                     },
                     position: (116, 33),
                    },
                   ],
                  },
                  position: (116, 22),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (152, 7),
                 },
                ],
               },
               to: 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),
                 },
                ],
                position: (152, 21),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "example",
                  position: (156, 7),
                 },
                ],
               },
               to: 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),
                   },
                  ],
                  position: (156, 35),
                 },
                ],
               },
              },
             ],
             recursive: false,
             position: (115, 24),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "database",
             position: (170, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "type",
                position: (171, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (171, 14),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (172, 9),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: Variable {
                    identifier: "enum",
                    position: (172, 16),
                   },
                   arguments: [
                    List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "SQLite",
                         position: (172, 24),
                        },
                       ],
                       position: (172, 23),
                      },
                      String {
                       parts: [
                        Raw {
                         content: "PostgreSQL",
                         position: (172, 33),
                        },
                       ],
                       position: (172, 32),
                      },
                      String {
                       parts: [
                        Raw {
                         content: "MySQL",
                         position: (172, 46),
                        },
                       ],
                       position: (172, 45),
                      },
                     ],
                     position: (172, 21),
                    },
                   ],
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (173, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "SQLite",
                     position: (173, 20),
                    },
                   ],
                   position: (173, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "example",
                     position: (174, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "MySQL",
                     position: (174, 20),
                    },
                   ],
                   position: (174, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (175, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "Database engine to use.",
                     position: (175, 24),
                    },
                   ],
                   position: (175, 23),
                  },
                 },
                ],
                recursive: false,
                position: (171, 23),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "host",
                position: (178, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (178, 14),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (179, 9),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (179, 16),
                   },
                   arguments: [
                    Variable {
                     identifier: "str",
                     position: (179, 23),
                    },
                   ],
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (180, 9),
                    },
                   ],
                  },
                  to: Variable {
                   identifier: "null",
                   position: (180, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (181, 9),
                    },
                   ],
                  },
                  to: 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),
                    },
                   ],
                   position: (181, 23),
                  },
                 },
                ],
                recursive: false,
                position: (178, 23),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "port",
                position: (194, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (194, 14),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (195, 9),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (195, 16),
                   },
                   arguments: [
                    Variable {
                     identifier: "port",
                     position: (195, 23),
                    },
                   ],
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (196, 9),
                    },
                   ],
                  },
                  to: Variable {
                   identifier: "null",
                   position: (196, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (197, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "Database port. Use <literal>null</literal> for default port.",
                     position: (197, 24),
                    },
                   ],
                   position: (197, 23),
                  },
                 },
                ],
                recursive: false,
                position: (194, 23),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "name",
                position: (200, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (200, 14),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (201, 9),
                    },
                   ],
                  },
                  to: Variable {
                   identifier: "str",
                   position: (201, 16),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (202, 9),
                    },
                   ],
                  },
                  to: IfThenElse {
                   predicate: BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (202, 22),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "database",
                         position: (202, 26),
                        },
                        Raw {
                         content: "type",
                         position: (202, 35),
                        },
                       ],
                      },
                      default: None,
                     },
                     String {
                      parts: [
                       Raw {
                        content: "SQLite",
                        position: (202, 44),
                       },
                      ],
                      position: (202, 43),
                     },
                    ],
                    position: (202, 40),
                   },
                   then: String {
                    parts: [
                     Expression {
                      expression: Variable {
                       identifier: "dataDir",
                       position: (202, 60),
                      },
                     },
                     Raw {
                      content: "/sympa.sqlite",
                      position: (202, 68),
                     },
                    ],
                    position: (202, 57),
                   },
                   else_: String {
                    parts: [
                     Raw {
                      content: "sympa",
                      position: (202, 89),
                     },
                    ],
                    position: (202, 88),
                   },
                   position: (202, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "defaultText",
                     position: (203, 9),
                    },
                   ],
                  },
                  to: 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),
                      },
                     ],
                     position: (203, 41),
                    },
                   ],
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (204, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "Database name. When using SQLite this must be an absolute\npath to the database file.\n",
                     position: (205, 1),
                    },
                   ],
                   position: (204, 23),
                  },
                 },
                ],
                recursive: false,
                position: (200, 23),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "user",
                position: (210, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (210, 14),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (211, 9),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (211, 16),
                   },
                   arguments: [
                    Variable {
                     identifier: "str",
                     position: (211, 23),
                    },
                   ],
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (212, 9),
                    },
                   ],
                  },
                  to: Variable {
                   identifier: "user",
                   position: (212, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (213, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "Database user. The system user name is used as a default.",
                     position: (213, 24),
                    },
                   ],
                   position: (213, 23),
                  },
                 },
                ],
                recursive: false,
                position: (210, 23),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "passwordFile",
                position: (216, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (216, 22),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (217, 9),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (217, 16),
                   },
                   arguments: [
                    Variable {
                     identifier: "path",
                     position: (217, 23),
                    },
                   ],
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (218, 9),
                    },
                   ],
                  },
                  to: Variable {
                   identifier: "null",
                   position: (218, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "example",
                     position: (219, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "/run/keys/sympa-dbpassword",
                     position: (219, 20),
                    },
                   ],
                   position: (219, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (220, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "A file containing the password for <option>services.sympa.database.user</option>.\n",
                     position: (221, 1),
                    },
                   ],
                   position: (220, 23),
                  },
                 },
                ],
                recursive: false,
                position: (216, 31),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "createLocally",
                position: (225, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (225, 23),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (226, 9),
                    },
                   ],
                  },
                  to: Variable {
                   identifier: "bool",
                   position: (226, 16),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (227, 9),
                    },
                   ],
                  },
                  to: Variable {
                   identifier: "true",
                   position: (227, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (228, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "Whether to create a local database automatically.",
                     position: (228, 24),
                    },
                   ],
                   position: (228, 23),
                  },
                 },
                ],
                recursive: false,
                position: (225, 32),
               },
              ],
             },
            },
           ],
           recursive: false,
           position: (170, 16),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "web",
             position: (232, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "enable",
                position: (233, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (233, 16),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (234, 9),
                    },
                   ],
                  },
                  to: Variable {
                   identifier: "bool",
                   position: (234, 16),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (235, 9),
                    },
                   ],
                  },
                  to: Variable {
                   identifier: "true",
                   position: (235, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (236, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "Whether to enable Sympa web interface.",
                     position: (236, 24),
                    },
                   ],
                   position: (236, 23),
                  },
                 },
                ],
                recursive: false,
                position: (233, 25),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "server",
                position: (239, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (239, 16),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (240, 9),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: Variable {
                    identifier: "enum",
                    position: (240, 16),
                   },
                   arguments: [
                    List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "nginx",
                         position: (240, 24),
                        },
                       ],
                       position: (240, 23),
                      },
                      String {
                       parts: [
                        Raw {
                         content: "none",
                         position: (240, 32),
                        },
                       ],
                       position: (240, 31),
                      },
                     ],
                     position: (240, 21),
                    },
                   ],
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (241, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "nginx",
                     position: (241, 20),
                    },
                   ],
                   position: (241, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (242, 9),
                    },
                   ],
                  },
                  to: 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),
                    },
                   ],
                   position: (242, 23),
                  },
                 },
                ],
                recursive: false,
                position: (239, 25),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "https",
                position: (249, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (249, 15),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (250, 9),
                    },
                   ],
                  },
                  to: Variable {
                   identifier: "bool",
                   position: (250, 16),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (251, 9),
                    },
                   ],
                  },
                  to: Variable {
                   identifier: "true",
                   position: (251, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (252, 9),
                    },
                   ],
                  },
                  to: 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),
                    },
                   ],
                   position: (252, 23),
                  },
                 },
                ],
                recursive: false,
                position: (249, 24),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "fcgiProcs",
                position: (258, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (258, 19),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (259, 9),
                    },
                   ],
                  },
                  to: PropertyAccess {
                   expression: Variable {
                    identifier: "ints",
                    position: (259, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "positive",
                      position: (259, 21),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (260, 9),
                    },
                   ],
                  },
                  to: Int {
                   value: 2,
                   position: (260, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (261, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "Number of FastCGI processes to fork.",
                     position: (261, 24),
                    },
                   ],
                   position: (261, 23),
                  },
                 },
                ],
                recursive: false,
                position: (258, 28),
               },
              ],
             },
            },
           ],
           recursive: false,
           position: (232, 11),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "mta",
             position: (265, 5),
            },
           ],
          },
          to: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "type",
                position: (266, 7),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (266, 14),
              },
              arguments: [
               Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "type",
                     position: (267, 9),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: Variable {
                    identifier: "enum",
                    position: (267, 16),
                   },
                   arguments: [
                    List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "postfix",
                         position: (267, 24),
                        },
                       ],
                       position: (267, 23),
                      },
                      String {
                       parts: [
                        Raw {
                         content: "none",
                         position: (267, 34),
                        },
                       ],
                       position: (267, 33),
                      },
                     ],
                     position: (267, 21),
                    },
                   ],
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "default",
                     position: (268, 9),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "postfix",
                     position: (268, 20),
                    },
                   ],
                   position: (268, 19),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "description",
                     position: (269, 9),
                    },
                   ],
                  },
                  to: 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),
                    },
                   ],
                   position: (269, 23),
                  },
                 },
                ],
                recursive: false,
                position: (266, 23),
               },
              ],
             },
            },
           ],
           recursive: false,
           position: (265, 11),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "settings",
             position: (279, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (279, 16),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "type",
                  position: (280, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "attrsOf",
                 position: (280, 14),
                },
                arguments: [
                 Parentheses {
                  expression: 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),
                    },
                   ],
                  },
                  position: (280, 22),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "default",
                  position: (281, 7),
                 },
                ],
               },
               to: Map {
                bindings: [],
                recursive: false,
                position: (281, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "example",
                  position: (282, 7),
                 },
                ],
               },
               to: 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),
                   },
                  ],
                  position: (282, 35),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (288, 7),
                 },
                ],
               },
               to: 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),
                 },
                ],
                position: (288, 21),
               },
              },
             ],
             recursive: false,
             position: (279, 25),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "settingsFile",
             position: (295, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (295, 20),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "type",
                  position: (296, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "attrsOf",
                 position: (296, 14),
                },
                arguments: [
                 Parentheses {
                  expression: FunctionApplication {
                   function: Variable {
                    identifier: "submodule",
                    position: (296, 23),
                   },
                   arguments: [
                    Parentheses {
                     expression: Function {
                      argument: Destructured {
                       identifier: None,
                       arguments: [
                        DestructuredArgument {
                         identifier: "name",
                         default: None,
                        },
                        DestructuredArgument {
                         identifier: "config",
                         default: None,
                        },
                       ],
                       ellipsis: true,
                      },
                      definition: Map {
                       bindings: [
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "options",
                            position: (297, 9),
                           },
                          ],
                         },
                         to: Map {
                          bindings: [
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "enable",
                               position: (298, 11),
                              },
                             ],
                            },
                            to: FunctionApplication {
                             function: Variable {
                              identifier: "mkOption",
                              position: (298, 20),
                             },
                             arguments: [
                              Map {
                               bindings: [
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "type",
                                    position: (299, 13),
                                   },
                                  ],
                                 },
                                 to: Variable {
                                  identifier: "bool",
                                  position: (299, 20),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "default",
                                    position: (300, 13),
                                   },
                                  ],
                                 },
                                 to: Variable {
                                  identifier: "true",
                                  position: (300, 23),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "description",
                                    position: (301, 13),
                                   },
                                  ],
                                 },
                                 to: String {
                                  parts: [
                                   Raw {
                                    content: "Whether this file should be generated. This option allows specific files to be disabled.",
                                    position: (301, 28),
                                   },
                                  ],
                                  position: (301, 27),
                                 },
                                },
                               ],
                               recursive: false,
                               position: (298, 29),
                              },
                             ],
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "text",
                               position: (303, 11),
                              },
                             ],
                            },
                            to: FunctionApplication {
                             function: Variable {
                              identifier: "mkOption",
                              position: (303, 18),
                             },
                             arguments: [
                              Map {
                               bindings: [
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "default",
                                    position: (304, 13),
                                   },
                                  ],
                                 },
                                 to: Variable {
                                  identifier: "null",
                                  position: (304, 23),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "type",
                                    position: (305, 13),
                                   },
                                  ],
                                 },
                                 to: FunctionApplication {
                                  function: Variable {
                                   identifier: "nullOr",
                                   position: (305, 20),
                                  },
                                  arguments: [
                                   Variable {
                                    identifier: "lines",
                                    position: (305, 27),
                                   },
                                  ],
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "description",
                                    position: (306, 13),
                                   },
                                  ],
                                 },
                                 to: String {
                                  parts: [
                                   Raw {
                                    content: "Text of the file.",
                                    position: (306, 28),
                                   },
                                  ],
                                  position: (306, 27),
                                 },
                                },
                               ],
                               recursive: false,
                               position: (303, 27),
                              },
                             ],
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "source",
                               position: (308, 11),
                              },
                             ],
                            },
                            to: FunctionApplication {
                             function: Variable {
                              identifier: "mkOption",
                              position: (308, 20),
                             },
                             arguments: [
                              Map {
                               bindings: [
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "type",
                                    position: (309, 13),
                                   },
                                  ],
                                 },
                                 to: Variable {
                                  identifier: "path",
                                  position: (309, 20),
                                 },
                                },
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "description",
                                    position: (310, 13),
                                   },
                                  ],
                                 },
                                 to: String {
                                  parts: [
                                   Raw {
                                    content: "Path of the source file.",
                                    position: (310, 28),
                                   },
                                  ],
                                  position: (310, 27),
                                 },
                                },
                               ],
                               recursive: false,
                               position: (308, 29),
                              },
                             ],
                            },
                           },
                          ],
                          recursive: false,
                          position: (297, 19),
                         },
                        },
                        Binding {
                         from: AttributePath {
                          parts: [
                           Raw {
                            content: "config",
                            position: (314, 9),
                           },
                           Raw {
                            content: "source",
                            position: (314, 16),
                           },
                          ],
                         },
                         to: FunctionApplication {
                          function: Variable {
                           identifier: "mkIf",
                           position: (314, 25),
                          },
                          arguments: [
                           Parentheses {
                            expression: BinaryOperation {
                             operator: NotEqualTo,
                             operands: [
                              PropertyAccess {
                               expression: Variable {
                                identifier: "config",
                                position: (314, 31),
                               },
                               attribute_path: AttributePath {
                                parts: [
                                 Raw {
                                  content: "text",
                                  position: (314, 38),
                                 },
                                ],
                               },
                               default: None,
                              },
                              Variable {
                               identifier: "null",
                               position: (314, 46),
                              },
                             ],
                             position: (314, 43),
                            },
                            position: (314, 30),
                           },
                           Parentheses {
                            expression: FunctionApplication {
                             function: Variable {
                              identifier: "mkDefault",
                              position: (314, 53),
                             },
                             arguments: [
                              Parentheses {
                               expression: FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "pkgs",
                                  position: (314, 64),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   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),
                                      },
                                     ],
                                    },
                                   },
                                  ],
                                  position: (314, 79),
                                 },
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "config",
                                   position: (314, 106),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "text",
                                     position: (314, 113),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                               position: (314, 63),
                              },
                             ],
                            },
                            position: (314, 52),
                           },
                          ],
                         },
                        },
                       ],
                       recursive: false,
                       position: (296, 57),
                      },
                      position: (296, 34),
                     },
                     position: (296, 33),
                    },
                   ],
                  },
                  position: (296, 22),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "default",
                  position: (316, 7),
                 },
                ],
               },
               to: Map {
                bindings: [],
                recursive: false,
                position: (316, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "example",
                  position: (317, 7),
                 },
                ],
               },
               to: 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),
                   },
                  ],
                  position: (317, 35),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (324, 7),
                 },
                ],
               },
               to: 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),
                 },
                ],
                position: (324, 21),
               },
              },
             ],
             recursive: false,
             position: (295, 29),
            },
           ],
          },
         },
        ],
        recursive: false,
        position: (81, 40),
       },
       position: (81, 28),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "config",
         position: (330, 3),
        },
       ],
      },
      to: FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (330, 12),
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (330, 17),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "enable",
            position: (330, 21),
           },
          ],
         },
         default: None,
        },
        Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "services",
              position: (332, 5),
             },
             Raw {
              content: "sympa",
              position: (332, 14),
             },
             Raw {
              content: "settings",
              position: (332, 20),
             },
            ],
           },
           to: Parentheses {
            expression: BinaryOperation {
             operator: Update,
             operands: [
              FunctionApplication {
               function: Variable {
                identifier: "mapAttrs",
                position: (332, 32),
               },
               arguments: [
                Parentheses {
                 expression: Function {
                  argument: Simple {
                   identifier: "_",
                  },
                  definition: Function {
                   argument: Simple {
                    identifier: "v",
                   },
                   definition: FunctionApplication {
                    function: Variable {
                     identifier: "mkDefault",
                     position: (332, 48),
                    },
                    arguments: [
                     Variable {
                      identifier: "v",
                      position: (332, 58),
                     },
                    ],
                   },
                   position: (332, 45),
                  },
                  position: (332, 42),
                 },
                 position: (332, 41),
                },
                Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "domain",
                      position: (333, 7),
                     },
                    ],
                   },
                   to: IfThenElse {
                    predicate: BinaryOperation {
                     operator: NotEqualTo,
                     operands: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (333, 23),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         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 {
                      parts: [
                       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),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "listmaster",
                      position: (334, 7),
                     },
                    ],
                   },
                   to: FunctionApplication {
                    function: Variable {
                     identifier: "concatStringsSep",
                     position: (334, 20),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: ",",
                        position: (334, 38),
                       },
                      ],
                      position: (334, 37),
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (334, 41),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "listMasters",
                         position: (334, 45),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "lang",
                      position: (335, 7),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (335, 20),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "lang",
                       position: (335, 24),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "home",
                      position: (337, 7),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Expression {
                      expression: Variable {
                       identifier: "dataDir",
                       position: (337, 24),
                      },
                     },
                     Raw {
                      content: "/list_data",
                      position: (337, 32),
                     },
                    ],
                    position: (337, 21),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "arc_path",
                      position: (338, 7),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Expression {
                      expression: Variable {
                       identifier: "dataDir",
                       position: (338, 24),
                      },
                     },
                     Raw {
                      content: "/arc",
                      position: (338, 32),
                     },
                    ],
                    position: (338, 21),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "bounce_path",
                      position: (339, 7),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Expression {
                      expression: Variable {
                       identifier: "dataDir",
                       position: (339, 24),
                      },
                     },
                     Raw {
                      content: "/bounce",
                      position: (339, 32),
                     },
                    ],
                    position: (339, 21),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "sendmail",
                      position: (341, 7),
                     },
                    ],
                   },
                   to: String {
                    parts: [
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (341, 21),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "system-sendmail",
                          position: (341, 26),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/bin/sendmail",
                      position: (341, 42),
                     },
                    ],
                    position: (341, 18),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "db_type",
                      position: (343, 7),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (343, 17),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "database",
                       position: (343, 21),
                      },
                      Raw {
                       content: "type",
                       position: (343, 30),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "db_name",
                      position: (344, 7),
                     },
                    ],
                   },
                   to: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (344, 17),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "database",
                       position: (344, 21),
                      },
                      Raw {
                       content: "name",
                       position: (344, 30),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                 ],
                 recursive: false,
                 position: (332, 61),
                },
               ],
              },
              BinaryOperation {
               operator: Update,
               operands: [
                Parentheses {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "optionalAttrs",
                   position: (346, 9),
                  },
                  arguments: [
                   Parentheses {
                    expression: BinaryOperation {
                     operator: NotEqualTo,
                     operands: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (346, 24),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "database",
                          position: (346, 28),
                         },
                         Raw {
                          content: "host",
                          position: (346, 37),
                         },
                        ],
                       },
                       default: None,
                      },
                      Variable {
                       identifier: "null",
                       position: (346, 45),
                      },
                     ],
                     position: (346, 42),
                    },
                    position: (346, 23),
                   },
                   Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "db_host",
                         position: (347, 7),
                        },
                       ],
                      },
                      to: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (347, 17),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "database",
                          position: (347, 21),
                         },
                         Raw {
                          content: "host",
                          position: (347, 30),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                    ],
                    recursive: false,
                    position: (346, 51),
                   },
                  ],
                 },
                 position: (346, 8),
                },
                BinaryOperation {
                 operator: Update,
                 operands: [
                  Parentheses {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "optionalAttrs",
                     position: (349, 9),
                    },
                    arguments: [
                     Variable {
                      identifier: "mysqlLocal",
                      position: (349, 23),
                     },
                     Map {
                      bindings: [
                       Binding {
                        from: AttributePath {
                         parts: [
                          Raw {
                           content: "db_host",
                           position: (350, 7),
                          },
                         ],
                        },
                        to: String {
                         parts: [
                          Raw {
                           content: "localhost",
                           position: (350, 18),
                          },
                         ],
                         position: (350, 17),
                        },
                       },
                      ],
                      recursive: false,
                      position: (349, 34),
                     },
                    ],
                   },
                   position: (349, 8),
                  },
                  BinaryOperation {
                   operator: Update,
                   operands: [
                    Parentheses {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "optionalAttrs",
                       position: (352, 9),
                      },
                      arguments: [
                       Variable {
                        identifier: "pgsqlLocal",
                        position: (352, 23),
                       },
                       Map {
                        bindings: [
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "db_host",
                             position: (353, 7),
                            },
                           ],
                          },
                          to: String {
                           parts: [
                            Raw {
                             content: "/run/postgresql",
                             position: (353, 18),
                            },
                           ],
                           position: (353, 17),
                          },
                         },
                        ],
                        recursive: false,
                        position: (352, 34),
                       },
                      ],
                     },
                     position: (352, 8),
                    },
                    BinaryOperation {
                     operator: Update,
                     operands: [
                      Parentheses {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "optionalAttrs",
                         position: (355, 9),
                        },
                        arguments: [
                         Parentheses {
                          expression: BinaryOperation {
                           operator: NotEqualTo,
                           operands: [
                            PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (355, 24),
                             },
                             attribute_path: AttributePath {
                              parts: [
                               Raw {
                                content: "database",
                                position: (355, 28),
                               },
                               Raw {
                                content: "port",
                                position: (355, 37),
                               },
                              ],
                             },
                             default: None,
                            },
                            Variable {
                             identifier: "null",
                             position: (355, 45),
                            },
                           ],
                           position: (355, 42),
                          },
                          position: (355, 23),
                         },
                         Map {
                          bindings: [
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "db_port",
                               position: (356, 7),
                              },
                             ],
                            },
                            to: PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (356, 17),
                             },
                             attribute_path: AttributePath {
                              parts: [
                               Raw {
                                content: "database",
                                position: (356, 21),
                               },
                               Raw {
                                content: "port",
                                position: (356, 30),
                               },
                              ],
                             },
                             default: None,
                            },
                           },
                          ],
                          recursive: false,
                          position: (355, 51),
                         },
                        ],
                       },
                       position: (355, 8),
                      },
                      BinaryOperation {
                       operator: Update,
                       operands: [
                        Parentheses {
                         expression: FunctionApplication {
                          function: Variable {
                           identifier: "optionalAttrs",
                           position: (358, 9),
                          },
                          arguments: [
                           Parentheses {
                            expression: BinaryOperation {
                             operator: NotEqualTo,
                             operands: [
                              PropertyAccess {
                               expression: Variable {
                                identifier: "cfg",
                                position: (358, 24),
                               },
                               attribute_path: AttributePath {
                                parts: [
                                 Raw {
                                  content: "database",
                                  position: (358, 28),
                                 },
                                 Raw {
                                  content: "user",
                                  position: (358, 37),
                                 },
                                ],
                               },
                               default: None,
                              },
                              Variable {
                               identifier: "null",
                               position: (358, 45),
                              },
                             ],
                             position: (358, 42),
                            },
                            position: (358, 23),
                           },
                           Map {
                            bindings: [
                             Binding {
                              from: AttributePath {
                               parts: [
                                Raw {
                                 content: "db_user",
                                 position: (359, 7),
                                },
                               ],
                              },
                              to: PropertyAccess {
                               expression: Variable {
                                identifier: "cfg",
                                position: (359, 17),
                               },
                               attribute_path: AttributePath {
                                parts: [
                                 Raw {
                                  content: "database",
                                  position: (359, 21),
                                 },
                                 Raw {
                                  content: "user",
                                  position: (359, 30),
                                 },
                                ],
                               },
                               default: None,
                              },
                             },
                            ],
                            recursive: false,
                            position: (358, 51),
                           },
                          ],
                         },
                         position: (358, 8),
                        },
                        BinaryOperation {
                         operator: Update,
                         operands: [
                          Parentheses {
                           expression: FunctionApplication {
                            function: Variable {
                             identifier: "optionalAttrs",
                             position: (361, 9),
                            },
                            arguments: [
                             Parentheses {
                              expression: BinaryOperation {
                               operator: EqualTo,
                               operands: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "cfg",
                                  position: (361, 24),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "mta",
                                    position: (361, 28),
                                   },
                                   Raw {
                                    content: "type",
                                    position: (361, 32),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "postfix",
                                   position: (361, 41),
                                  },
                                 ],
                                 position: (361, 40),
                                },
                               ],
                               position: (361, 37),
                              },
                              position: (361, 23),
                             },
                             Map {
                              bindings: [
                               Binding {
                                from: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "sendmail_aliases",
                                   position: (362, 7),
                                  },
                                 ],
                                },
                                to: String {
                                 parts: [
                                  Expression {
                                   expression: Variable {
                                    identifier: "dataDir",
                                    position: (362, 29),
                                   },
                                  },
                                  Raw {
                                   content: "/sympa_transport",
                                   position: (362, 37),
                                  },
                                 ],
                                 position: (362, 26),
                                },
                               },
                               Binding {
                                from: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "aliases_program",
                                   position: (363, 7),
                                  },
                                 ],
                                },
                                to: String {
                                 parts: [
                                  Expression {
                                   expression: PropertyAccess {
                                    expression: Variable {
                                     identifier: "pkgs",
                                     position: (363, 29),
                                    },
                                    attribute_path: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "postfix",
                                       position: (363, 34),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                  },
                                  Raw {
                                   content: "/bin/postmap",
                                   position: (363, 42),
                                  },
                                 ],
                                 position: (363, 26),
                                },
                               },
                               Binding {
                                from: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "aliases_db_type",
                                   position: (364, 7),
                                  },
                                 ],
                                },
                                to: String {
                                 parts: [
                                  Raw {
                                   content: "hash",
                                   position: (364, 27),
                                  },
                                 ],
                                 position: (364, 26),
                                },
                               },
                              ],
                              recursive: false,
                              position: (361, 51),
                             },
                            ],
                           },
                           position: (361, 8),
                          },
                          Parentheses {
                           expression: FunctionApplication {
                            function: Variable {
                             identifier: "optionalAttrs",
                             position: (366, 9),
                            },
                            arguments: [
                             PropertyAccess {
                              expression: Variable {
                               identifier: "cfg",
                               position: (366, 23),
                              },
                              attribute_path: AttributePath {
                               parts: [
                                Raw {
                                 content: "web",
                                 position: (366, 27),
                                },
                                Raw {
                                 content: "enable",
                                 position: (366, 31),
                                },
                               ],
                              },
                              default: None,
                             },
                             Map {
                              bindings: [
                               Binding {
                                from: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "static_content_path",
                                   position: (367, 7),
                                  },
                                 ],
                                },
                                to: String {
                                 parts: [
                                  Expression {
                                   expression: Variable {
                                    identifier: "dataDir",
                                    position: (367, 32),
                                   },
                                  },
                                  Raw {
                                   content: "/static_content",
                                   position: (367, 40),
                                  },
                                 ],
                                 position: (367, 29),
                                },
                               },
                               Binding {
                                from: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "css_path",
                                   position: (368, 7),
                                  },
                                 ],
                                },
                                to: String {
                                 parts: [
                                  Expression {
                                   expression: Variable {
                                    identifier: "dataDir",
                                    position: (368, 32),
                                   },
                                  },
                                  Raw {
                                   content: "/static_content/css",
                                   position: (368, 40),
                                  },
                                 ],
                                 position: (368, 29),
                                },
                               },
                               Binding {
                                from: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "pictures_path",
                                   position: (369, 7),
                                  },
                                 ],
                                },
                                to: String {
                                 parts: [
                                  Expression {
                                   expression: Variable {
                                    identifier: "dataDir",
                                    position: (369, 32),
                                   },
                                  },
                                  Raw {
                                   content: "/static_content/pictures",
                                   position: (369, 40),
                                  },
                                 ],
                                 position: (369, 29),
                                },
                               },
                               Binding {
                                from: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "mhonarc",
                                   position: (370, 7),
                                  },
                                 ],
                                },
                                to: String {
                                 parts: [
                                  Expression {
                                   expression: PropertyAccess {
                                    expression: Variable {
                                     identifier: "pkgs",
                                     position: (370, 32),
                                    },
                                    attribute_path: AttributePath {
                                     parts: [
                                      Raw {
                                       content: "perlPackages",
                                       position: (370, 37),
                                      },
                                      Raw {
                                       content: "MHonArc",
                                       position: (370, 50),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                  },
                                  Raw {
                                   content: "/bin/mhonarc",
                                   position: (370, 58),
                                  },
                                 ],
                                 position: (370, 29),
                                },
                               },
                              ],
                              recursive: false,
                              position: (366, 38),
                             },
                            ],
                           },
                           position: (366, 8),
                          },
                         ],
                         position: (366, 5),
                        },
                       ],
                       position: (361, 5),
                      },
                     ],
                     position: (358, 5),
                    },
                   ],
                   position: (355, 5),
                  },
                 ],
                 position: (352, 5),
                },
               ],
               position: (349, 5),
              },
             ],
             position: (346, 5),
            },
            position: (332, 31),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "services",
              position: (373, 5),
             },
             Raw {
              content: "sympa",
              position: (373, 14),
             },
             Raw {
              content: "settingsFile",
              position: (373, 20),
             },
            ],
           },
           to: BinaryOperation {
            operator: Update,
            operands: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Expression {
                   expression: String {
                    parts: [
                     Raw {
                      content: "virtual.sympa",
                      position: (374, 8),
                     },
                    ],
                    position: (374, 7),
                   },
                  },
                 ],
                },
                to: FunctionApplication {
                 function: Variable {
                  identifier: "mkDefault",
                  position: (374, 32),
                 },
                 arguments: [
                  Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "source",
                        position: (374, 44),
                       },
                      ],
                     },
                     to: Variable {
                      identifier: "virtual",
                      position: (374, 53),
                     },
                    },
                   ],
                   recursive: false,
                   position: (374, 42),
                  },
                 ],
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Expression {
                   expression: String {
                    parts: [
                     Raw {
                      content: "transport.sympa",
                      position: (375, 8),
                     },
                    ],
                    position: (375, 7),
                   },
                  },
                 ],
                },
                to: FunctionApplication {
                 function: Variable {
                  identifier: "mkDefault",
                  position: (375, 32),
                 },
                 arguments: [
                  Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "source",
                        position: (375, 44),
                       },
                      ],
                     },
                     to: Variable {
                      identifier: "transport",
                      position: (375, 53),
                     },
                    },
                   ],
                   recursive: false,
                   position: (375, 42),
                  },
                 ],
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Expression {
                   expression: String {
                    parts: [
                     Raw {
                      content: "etc/list_aliases.tt2",
                      position: (376, 8),
                     },
                    ],
                    position: (376, 7),
                   },
                  },
                 ],
                },
                to: FunctionApplication {
                 function: Variable {
                  identifier: "mkDefault",
                  position: (376, 32),
                 },
                 arguments: [
                  Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "source",
                        position: (376, 44),
                       },
                      ],
                     },
                     to: Variable {
                      identifier: "listAliases",
                      position: (376, 53),
                     },
                    },
                   ],
                   recursive: false,
                   position: (376, 42),
                  },
                 ],
                },
               },
              ],
              recursive: false,
              position: (373, 35),
             },
             Parentheses {
              expression: 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 {
                  parts: [
                   Raw {
                    content: "domains",
                    position: (378, 28),
                   },
                  ],
                 },
                 default: None,
                },
                Parentheses {
                 expression: Function {
                  argument: Simple {
                   identifier: "fqdn",
                  },
                  definition: Function {
                   argument: Simple {
                    identifier: "domain",
                   },
                   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),
                       },
                      ],
                      position: (379, 25),
                     },
                     Parentheses {
                      expression: FunctionApplication {
                       function: Variable {
                        identifier: "mkDefault",
                        position: (379, 51),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          Binding {
                           from: AttributePath {
                            parts: [
                             Raw {
                              content: "source",
                              position: (379, 63),
                             },
                            ],
                           },
                           to: 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: (379, 50),
                     },
                    ],
                   },
                   position: (378, 43),
                  },
                  position: (378, 37),
                 },
                 position: (378, 36),
                },
               ],
              },
              position: (378, 8),
             },
            ],
            position: (378, 5),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "environment",
              position: (381, 5),
             },
            ],
           },
           to: Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "systemPackages",
                 position: (382, 7),
                },
               ],
              },
              to: List {
               elements: [
                Variable {
                 identifier: "pkg",
                 position: (382, 26),
                },
               ],
               position: (382, 24),
              },
             },
            ],
            recursive: false,
            position: (381, 19),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "users",
              position: (385, 5),
             },
             Raw {
              content: "users",
              position: (385, 11),
             },
             Expression {
              expression: Variable {
               identifier: "user",
               position: (385, 19),
              },
             },
            ],
           },
           to: Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (386, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "Sympa mailing list manager user",
                 position: (386, 22),
                },
               ],
               position: (386, 21),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "group",
                 position: (387, 7),
                },
               ],
              },
              to: Variable {
               identifier: "group",
               position: (387, 15),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "home",
                 position: (388, 7),
                },
               ],
              },
              to: Variable {
               identifier: "dataDir",
               position: (388, 14),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "createHome",
                 position: (389, 7),
                },
               ],
              },
              to: Variable {
               identifier: "false",
               position: (389, 20),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "isSystemUser",
                 position: (390, 7),
                },
               ],
              },
              to: Variable {
               identifier: "true",
               position: (390, 22),
              },
             },
            ],
            recursive: false,
            position: (385, 27),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "users",
              position: (393, 5),
             },
             Raw {
              content: "groups",
              position: (393, 11),
             },
             Expression {
              expression: Variable {
               identifier: "group",
               position: (393, 20),
              },
             },
            ],
           },
           to: Map {
            bindings: [],
            recursive: false,
            position: (393, 29),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "assertions",
              position: (395, 5),
             },
            ],
           },
           to: List {
            elements: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "assertion",
                   position: (396, 9),
                  },
                 ],
                },
                to: BinaryOperation {
                 operator: Implication,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (396, 21),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     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 {
                      parts: [
                       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),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "message",
                   position: (397, 9),
                  },
                 ],
                },
                to: 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),
                  },
                 ],
                 position: (397, 19),
                },
               },
              ],
              recursive: false,
              position: (396, 7),
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "assertion",
                   position: (399, 9),
                  },
                 ],
                },
                to: BinaryOperation {
                 operator: Implication,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (399, 21),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     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 {
                      parts: [
                       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),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "message",
                   position: (400, 9),
                  },
                 ],
                },
                to: String {
                 parts: [
                  Raw {
                   content: "a password cannot be specified if services.sympa.database.createLocally is set to true",
                   position: (400, 20),
                  },
                 ],
                 position: (400, 19),
                },
               },
              ],
              recursive: false,
              position: (399, 7),
             },
            ],
            position: (395, 18),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "systemd",
              position: (404, 5),
             },
             Raw {
              content: "tmpfiles",
              position: (404, 13),
             },
             Raw {
              content: "rules",
              position: (404, 22),
             },
            ],
           },
           to: 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),
                 },
                ],
                position: (405, 7),
               },
               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),
                 },
                ],
                position: (406, 7),
               },
               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),
                 },
                ],
                position: (407, 7),
               },
               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),
                 },
                ],
                position: (408, 7),
               },
               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),
                 },
                ],
                position: (409, 7),
               },
               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),
                 },
                ],
                position: (410, 7),
               },
               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),
                 },
                ],
                position: (411, 7),
               },
               String {
                parts: [
                 Raw {
                  content: "R  ",
                  position: (415, 8),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "dataDir",
                   position: (415, 13),
                  },
                 },
                 Raw {
                  content: "/static_content    -    -       -        - -",
                  position: (415, 21),
                 },
                ],
                position: (415, 7),
               },
               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),
                 },
                ],
                position: (416, 7),
               },
               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),
                 },
                ],
                position: (417, 7),
               },
               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: (419, 7),
               },
              ],
              position: (404, 30),
             },
             BinaryOperation {
              operator: Concatenation,
              operands: [
               Parentheses {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "flip",
                  position: (421, 9),
                 },
                 arguments: [
                  Variable {
                   identifier: "concatMap",
                   position: (421, 14),
                  },
                  Variable {
                   identifier: "fqdns",
                   position: (421, 24),
                  },
                  Parentheses {
                   expression: Function {
                    argument: Simple {
                     identifier: "fqdn",
                    },
                    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),
                        },
                       ],
                       position: (422, 7),
                      },
                      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: (423, 7),
                      },
                     ],
                     position: (421, 37),
                    },
                    position: (421, 31),
                   },
                   position: (421, 30),
                  },
                 ],
                },
                position: (421, 8),
               },
               Parentheses {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "concatLists",
                  position: (428, 9),
                 },
                 arguments: [
                  Parentheses {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "flip",
                     position: (428, 22),
                    },
                    arguments: [
                     Variable {
                      identifier: "mapAttrsToList",
                      position: (428, 27),
                     },
                     Variable {
                      identifier: "enabledFiles",
                      position: (428, 42),
                     },
                     Parentheses {
                      expression: Function {
                       argument: Simple {
                        identifier: "k",
                       },
                       definition: Function {
                        argument: Simple {
                         identifier: "v",
                        },
                        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),
                            },
                           ],
                           position: (431, 7),
                          },
                          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 {
                               parts: [
                                Raw {
                                 content: "source",
                                 position: (432, 68),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                           ],
                           position: (432, 7),
                          },
                         ],
                         position: (428, 62),
                        },
                        position: (428, 59),
                       },
                       position: (428, 56),
                      },
                      position: (428, 55),
                     },
                    ],
                   },
                   position: (428, 21),
                  },
                 ],
                },
                position: (428, 8),
               },
              ],
              position: (428, 5),
             },
            ],
            position: (421, 5),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "systemd",
              position: (435, 5),
             },
             Raw {
              content: "services",
              position: (435, 13),
             },
             Raw {
              content: "sympa",
              position: (435, 22),
             },
            ],
           },
           to: Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (436, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "Sympa mailing list manager",
                 position: (436, 22),
                },
               ],
               position: (436, 21),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "wantedBy",
                 position: (438, 7),
                },
               ],
              },
              to: List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "multi-user.target",
                   position: (438, 21),
                  },
                 ],
                 position: (438, 20),
                },
               ],
               position: (438, 18),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "after",
                 position: (439, 7),
                },
               ],
              },
              to: List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "network-online.target",
                   position: (439, 18),
                  },
                 ],
                 position: (439, 17),
                },
               ],
               position: (439, 15),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "wants",
                 position: (440, 7),
                },
               ],
              },
              to: Variable {
               identifier: "sympaSubServices",
               position: (440, 15),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "before",
                 position: (441, 7),
                },
               ],
              },
              to: Variable {
               identifier: "sympaSubServices",
               position: (441, 16),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "serviceConfig",
                 position: (442, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "sympaServiceConfig",
                position: (442, 23),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "sympa_msg",
                   position: (442, 43),
                  },
                 ],
                 position: (442, 42),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "preStart",
                 position: (444, 7),
                },
               ],
              },
              to: 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: [
                   Parentheses {
                    expression: BinaryOperation {
                     operator: NotEqualTo,
                     operands: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (448, 27),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "database",
                          position: (448, 31),
                         },
                         Raw {
                          content: "passwordFile",
                          position: (448, 40),
                         },
                        ],
                       },
                       default: None,
                      },
                      Variable {
                       identifier: "null",
                       position: (448, 56),
                      },
                     ],
                     position: (448, 53),
                    },
                    position: (448, 26),
                   },
                   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 {
                        parts: [
                         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),
                     },
                    ],
                    position: (448, 62),
                   },
                  ],
                 },
                },
                Raw {
                 content: "\n\n",
                 position: (452, 12),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "optionalString",
                   position: (454, 11),
                  },
                  arguments: [
                   Parentheses {
                    expression: BinaryOperation {
                     operator: EqualTo,
                     operands: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (454, 27),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "mta",
                          position: (454, 31),
                         },
                         Raw {
                          content: "type",
                          position: (454, 35),
                         },
                        ],
                       },
                       default: None,
                      },
                      String {
                       parts: [
                        Raw {
                         content: "postfix",
                         position: (454, 44),
                        },
                       ],
                       position: (454, 43),
                      },
                     ],
                     position: (454, 40),
                    },
                    position: (454, 26),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "",
                      position: (455, 1),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (455, 13),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         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 {
                        parts: [
                         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),
                     },
                    ],
                    position: (454, 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),
                },
               ],
               position: (444, 18),
              },
             },
            ],
            recursive: false,
            position: (435, 30),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "systemd",
              position: (462, 5),
             },
             Raw {
              content: "services",
              position: (462, 13),
             },
             Raw {
              content: "sympa-archive",
              position: (462, 22),
             },
            ],
           },
           to: Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (463, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "Sympa mailing list manager (archiving)",
                 position: (463, 22),
                },
               ],
               position: (463, 21),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "bindsTo",
                 position: (464, 7),
                },
               ],
              },
              to: List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "sympa.service",
                   position: (464, 20),
                  },
                 ],
                 position: (464, 19),
                },
               ],
               position: (464, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "serviceConfig",
                 position: (465, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "sympaServiceConfig",
                position: (465, 23),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "archived",
                   position: (465, 43),
                  },
                 ],
                 position: (465, 42),
                },
               ],
              },
             },
            ],
            recursive: false,
            position: (462, 38),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "systemd",
              position: (467, 5),
             },
             Raw {
              content: "services",
              position: (467, 13),
             },
             Raw {
              content: "sympa-bounce",
              position: (467, 22),
             },
            ],
           },
           to: Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (468, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "Sympa mailing list manager (bounce processing)",
                 position: (468, 22),
                },
               ],
               position: (468, 21),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "bindsTo",
                 position: (469, 7),
                },
               ],
              },
              to: List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "sympa.service",
                   position: (469, 20),
                  },
                 ],
                 position: (469, 19),
                },
               ],
               position: (469, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "serviceConfig",
                 position: (470, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "sympaServiceConfig",
                position: (470, 23),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "bounced",
                   position: (470, 43),
                  },
                 ],
                 position: (470, 42),
                },
               ],
              },
             },
            ],
            recursive: false,
            position: (467, 37),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "systemd",
              position: (472, 5),
             },
             Raw {
              content: "services",
              position: (472, 13),
             },
             Raw {
              content: "sympa-bulk",
              position: (472, 22),
             },
            ],
           },
           to: Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (473, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "Sympa mailing list manager (message distribution)",
                 position: (473, 22),
                },
               ],
               position: (473, 21),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "bindsTo",
                 position: (474, 7),
                },
               ],
              },
              to: List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "sympa.service",
                   position: (474, 20),
                  },
                 ],
                 position: (474, 19),
                },
               ],
               position: (474, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "serviceConfig",
                 position: (475, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "sympaServiceConfig",
                position: (475, 23),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "bulk",
                   position: (475, 43),
                  },
                 ],
                 position: (475, 42),
                },
               ],
              },
             },
            ],
            recursive: false,
            position: (472, 35),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "systemd",
              position: (477, 5),
             },
             Raw {
              content: "services",
              position: (477, 13),
             },
             Raw {
              content: "sympa-task",
              position: (477, 22),
             },
            ],
           },
           to: Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (478, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "Sympa mailing list manager (task management)",
                 position: (478, 22),
                },
               ],
               position: (478, 21),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "bindsTo",
                 position: (479, 7),
                },
               ],
              },
              to: List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "sympa.service",
                   position: (479, 20),
                  },
                 ],
                 position: (479, 19),
                },
               ],
               position: (479, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "serviceConfig",
                 position: (480, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: Variable {
                identifier: "sympaServiceConfig",
                position: (480, 23),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "task_manager",
                   position: (480, 43),
                  },
                 ],
                 position: (480, 42),
                },
               ],
              },
             },
            ],
            recursive: false,
            position: (477, 35),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "systemd",
              position: (483, 5),
             },
             Raw {
              content: "services",
              position: (483, 13),
             },
             Raw {
              content: "wwsympa",
              position: (483, 22),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (483, 32),
            },
            arguments: [
             Variable {
              identifier: "usingNginx",
              position: (483, 37),
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "wantedBy",
                   position: (484, 7),
                  },
                 ],
                },
                to: List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "multi-user.target",
                     position: (484, 21),
                    },
                   ],
                   position: (484, 20),
                  },
                 ],
                 position: (484, 18),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "after",
                   position: (485, 7),
                  },
                 ],
                },
                to: List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "sympa.service",
                     position: (485, 18),
                    },
                   ],
                   position: (485, 17),
                  },
                 ],
                 position: (485, 15),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "serviceConfig",
                   position: (486, 7),
                  },
                 ],
                },
                to: BinaryOperation {
                 operator: Update,
                 operands: [
                  Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "Type",
                        position: (487, 9),
                       },
                      ],
                     },
                     to: String {
                      parts: [
                       Raw {
                        content: "forking",
                        position: (487, 17),
                       },
                      ],
                      position: (487, 16),
                     },
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "PIDFile",
                        position: (488, 9),
                       },
                      ],
                     },
                     to: String {
                      parts: [
                       Raw {
                        content: "/run/sympa/wwsympa.pid",
                        position: (488, 20),
                       },
                      ],
                      position: (488, 19),
                     },
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "Restart",
                        position: (489, 9),
                       },
                      ],
                     },
                     to: String {
                      parts: [
                       Raw {
                        content: "always",
                        position: (489, 20),
                       },
                      ],
                      position: (489, 19),
                     },
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "ExecStart",
                        position: (490, 9),
                       },
                      ],
                     },
                     to: String {
                      parts: [
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "pkgs",
                          position: (490, 25),
                         },
                         attribute_path: AttributePath {
                          parts: [
                           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 {
                            parts: [
                             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),
                       },
                      ],
                      position: (490, 21),
                     },
                    },
                   ],
                   recursive: false,
                   position: (486, 23),
                  },
                  Variable {
                   identifier: "commonServiceConfig",
                   position: (501, 12),
                  },
                 ],
                 position: (501, 9),
                },
               },
              ],
              recursive: false,
              position: (483, 48),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "services",
              position: (504, 5),
             },
             Raw {
              content: "nginx",
              position: (504, 14),
             },
             Raw {
              content: "enable",
              position: (504, 20),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (504, 29),
            },
            arguments: [
             Variable {
              identifier: "usingNginx",
              position: (504, 34),
             },
             Variable {
              identifier: "true",
              position: (504, 45),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "services",
              position: (505, 5),
             },
             Raw {
              content: "nginx",
              position: (505, 14),
             },
             Raw {
              content: "virtualHosts",
              position: (505, 20),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (505, 35),
            },
            arguments: [
             Variable {
              identifier: "usingNginx",
              position: (505, 40),
             },
             Parentheses {
              expression: LetIn {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "vHosts",
                    position: (506, 7),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "unique",
                   position: (506, 16),
                  },
                  arguments: [
                   Parentheses {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "remove",
                      position: (506, 24),
                     },
                     arguments: [
                      Variable {
                       identifier: "null",
                       position: (506, 31),
                      },
                      Parentheses {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "mapAttrsToList",
                         position: (506, 37),
                        },
                        arguments: [
                         Parentheses {
                          expression: Function {
                           argument: Simple {
                            identifier: "_k",
                           },
                           definition: Function {
                            argument: Simple {
                             identifier: "v",
                            },
                            definition: PropertyAccess {
                             expression: Variable {
                              identifier: "v",
                              position: (506, 60),
                             },
                             attribute_path: AttributePath {
                              parts: [
                               Raw {
                                content: "webHost",
                                position: (506, 62),
                               },
                              ],
                             },
                             default: None,
                            },
                            position: (506, 57),
                           },
                           position: (506, 53),
                          },
                          position: (506, 52),
                         },
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (506, 71),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "domains",
                             position: (506, 75),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                       position: (506, 36),
                      },
                     ],
                    },
                    position: (506, 23),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "hostLocations",
                    position: (507, 7),
                   },
                  ],
                 },
                 to: Function {
                  argument: Simple {
                   identifier: "host",
                  },
                  definition: FunctionApplication {
                   function: Variable {
                    identifier: "map",
                    position: (507, 29),
                   },
                   arguments: [
                    Parentheses {
                     expression: Function {
                      argument: Simple {
                       identifier: "v",
                      },
                      definition: PropertyAccess {
                       expression: Variable {
                        identifier: "v",
                        position: (507, 37),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "webLocation",
                          position: (507, 39),
                         },
                        ],
                       },
                       default: None,
                      },
                      position: (507, 34),
                     },
                     position: (507, 33),
                    },
                    Parentheses {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "filter",
                       position: (507, 53),
                      },
                      arguments: [
                       Parentheses {
                        expression: Function {
                         argument: Simple {
                          identifier: "v",
                         },
                         definition: BinaryOperation {
                          operator: EqualTo,
                          operands: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "v",
                             position: (507, 64),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "webHost",
                               position: (507, 66),
                              },
                             ],
                            },
                            default: None,
                           },
                           Variable {
                            identifier: "host",
                            position: (507, 77),
                           },
                          ],
                          position: (507, 74),
                         },
                         position: (507, 61),
                        },
                        position: (507, 60),
                       },
                       Parentheses {
                        expression: FunctionApplication {
                         function: Variable {
                          identifier: "attrValues",
                          position: (507, 84),
                         },
                         arguments: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (507, 95),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "domains",
                              position: (507, 99),
                             },
                            ],
                           },
                           default: None,
                          },
                         ],
                        },
                        position: (507, 83),
                       },
                      ],
                     },
                     position: (507, 52),
                    },
                   ],
                  },
                  position: (507, 23),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "httpsOpts",
                    position: (508, 7),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "optionalAttrs",
                   position: (508, 19),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (508, 33),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "web",
                       position: (508, 37),
                      },
                      Raw {
                       content: "https",
                       position: (508, 41),
                      },
                     ],
                    },
                    default: None,
                   },
                   Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "forceSSL",
                         position: (508, 49),
                        },
                       ],
                      },
                      to: FunctionApplication {
                       function: Variable {
                        identifier: "mkDefault",
                        position: (508, 60),
                       },
                       arguments: [
                        Variable {
                         identifier: "true",
                         position: (508, 70),
                        },
                       ],
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "enableACME",
                         position: (508, 76),
                        },
                       ],
                      },
                      to: 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),
                 },
                 Parentheses {
                  expression: Function {
                   argument: Simple {
                    identifier: "host",
                   },
                   definition: BinaryOperation {
                    operator: Update,
                    operands: [
                     Map {
                      bindings: [
                       Binding {
                        from: AttributePath {
                         parts: [
                          Raw {
                           content: "locations",
                           position: (511, 7),
                          },
                         ],
                        },
                        to: BinaryOperation {
                         operator: Update,
                         operands: [
                          FunctionApplication {
                           function: Variable {
                            identifier: "genAttrs",
                            position: (511, 19),
                           },
                           arguments: [
                            Parentheses {
                             expression: FunctionApplication {
                              function: Variable {
                               identifier: "hostLocations",
                               position: (511, 29),
                              },
                              arguments: [
                               Variable {
                                identifier: "host",
                                position: (511, 43),
                               },
                              ],
                             },
                             position: (511, 28),
                            },
                            Parentheses {
                             expression: Function {
                              argument: Simple {
                               identifier: "loc",
                              },
                              definition: Map {
                               bindings: [
                                Binding {
                                 from: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "extraConfig",
                                    position: (512, 9),
                                   },
                                  ],
                                 },
                                 to: String {
                                  parts: [
                                   Raw {
                                    content: "include ",
                                    position: (513, 1),
                                   },
                                   Expression {
                                    expression: PropertyAccess {
                                     expression: Variable {
                                      identifier: "config",
                                      position: (513, 21),
                                     },
                                     attribute_path: AttributePath {
                                      parts: [
                                       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),
                                   },
                                  ],
                                  position: (512, 23),
                                 },
                                },
                               ],
                               recursive: false,
                               position: (511, 55),
                              },
                              position: (511, 50),
                             },
                             position: (511, 49),
                            },
                           ],
                          },
                          Map {
                           bindings: [
                            Binding {
                             from: AttributePath {
                              parts: [
                               Expression {
                                expression: String {
                                 parts: [
                                  Raw {
                                   content: "/static-sympa/",
                                   position: (518, 10),
                                  },
                                 ],
                                 position: (518, 9),
                                },
                               },
                               Raw {
                                content: "alias",
                                position: (518, 26),
                               },
                              ],
                             },
                             to: String {
                              parts: [
                               Expression {
                                expression: Variable {
                                 identifier: "dataDir",
                                 position: (518, 37),
                                },
                               },
                               Raw {
                                content: "/static_content/",
                                position: (518, 45),
                               },
                              ],
                              position: (518, 34),
                             },
                            },
                           ],
                           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: (510, 21),
                 },
                ],
               },
               position: (505, 52),
              },
              position: (505, 51),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "services",
              position: (522, 5),
             },
             Raw {
              content: "postfix",
              position: (522, 14),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (522, 24),
            },
            arguments: [
             Parentheses {
              expression: BinaryOperation {
               operator: EqualTo,
               operands: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (522, 30),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "mta",
                    position: (522, 34),
                   },
                   Raw {
                    content: "type",
                    position: (522, 38),
                   },
                  ],
                 },
                 default: None,
                },
                String {
                 parts: [
                  Raw {
                   content: "postfix",
                   position: (522, 47),
                  },
                 ],
                 position: (522, 46),
                },
               ],
               position: (522, 43),
              },
              position: (522, 29),
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "enable",
                   position: (523, 7),
                  },
                 ],
                },
                to: Variable {
                 identifier: "true",
                 position: (523, 16),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "recipientDelimiter",
                   position: (524, 7),
                  },
                 ],
                },
                to: String {
                 parts: [
                  Raw {
                   content: "+",
                   position: (524, 29),
                  },
                 ],
                 position: (524, 28),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "config",
                   position: (525, 7),
                  },
                 ],
                },
                to: Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "virtual_alias_maps",
                      position: (526, 9),
                     },
                    ],
                   },
                   to: 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, 32),
                     },
                    ],
                    position: (526, 30),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "virtual_mailbox_maps",
                      position: (527, 9),
                     },
                    ],
                   },
                   to: 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),
                       },
                      ],
                      position: (528, 11),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "hash:",
                        position: (529, 12),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "dataDir",
                         position: (529, 19),
                        },
                       },
                       Raw {
                        content: "/sympa_transport",
                        position: (529, 27),
                       },
                      ],
                      position: (529, 11),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "hash:",
                        position: (530, 12),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "dataDir",
                         position: (530, 19),
                        },
                       },
                       Raw {
                        content: "/virtual.sympa",
                        position: (530, 27),
                       },
                      ],
                      position: (530, 11),
                     },
                    ],
                    position: (527, 32),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "virtual_mailbox_domains",
                      position: (532, 9),
                     },
                    ],
                   },
                   to: 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, 37),
                     },
                    ],
                    position: (532, 35),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "transport_maps",
                      position: (533, 9),
                     },
                    ],
                   },
                   to: 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),
                       },
                      ],
                      position: (534, 11),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "hash:",
                        position: (535, 12),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "dataDir",
                         position: (535, 19),
                        },
                       },
                       Raw {
                        content: "/sympa_transport",
                        position: (535, 27),
                       },
                      ],
                      position: (535, 11),
                     },
                    ],
                    position: (533, 26),
                   },
                  },
                 ],
                 recursive: false,
                 position: (525, 16),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "masterConfig",
                   position: (538, 7),
                  },
                 ],
                },
                to: Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "sympa",
                         position: (539, 10),
                        },
                       ],
                       position: (539, 9),
                      },
                     },
                    ],
                   },
                   to: Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "type",
                         position: (540, 11),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "unix",
                         position: (540, 19),
                        },
                       ],
                       position: (540, 18),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "privileged",
                         position: (541, 11),
                        },
                       ],
                      },
                      to: Variable {
                       identifier: "true",
                       position: (541, 24),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "chroot",
                         position: (542, 11),
                        },
                       ],
                      },
                      to: Variable {
                       identifier: "false",
                       position: (542, 20),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "command",
                         position: (543, 11),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "pipe",
                         position: (543, 22),
                        },
                       ],
                       position: (543, 21),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "args",
                         position: (544, 11),
                        },
                       ],
                      },
                      to: List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "flags=hqRu",
                           position: (545, 14),
                          },
                         ],
                         position: (545, 13),
                        },
                        String {
                         parts: [
                          Raw {
                           content: "user=",
                           position: (546, 14),
                          },
                          Expression {
                           expression: Variable {
                            identifier: "user",
                            position: (546, 21),
                           },
                          },
                         ],
                         position: (546, 13),
                        },
                        String {
                         parts: [
                          Raw {
                           content: "argv=",
                           position: (547, 14),
                          },
                          Expression {
                           expression: Variable {
                            identifier: "pkg",
                            position: (547, 21),
                           },
                          },
                          Raw {
                           content: "/libexec/queue",
                           position: (547, 25),
                          },
                         ],
                         position: (547, 13),
                        },
                        String {
                         parts: [
                          Raw {
                           content: "${nexthop}",
                           position: (548, 14),
                          },
                         ],
                         position: (548, 13),
                        },
                       ],
                       position: (544, 18),
                      },
                     },
                    ],
                    recursive: false,
                    position: (539, 19),
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "sympabounce",
                         position: (551, 10),
                        },
                       ],
                       position: (551, 9),
                      },
                     },
                    ],
                   },
                   to: Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "type",
                         position: (552, 11),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "unix",
                         position: (552, 19),
                        },
                       ],
                       position: (552, 18),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "privileged",
                         position: (553, 11),
                        },
                       ],
                      },
                      to: Variable {
                       identifier: "true",
                       position: (553, 24),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "chroot",
                         position: (554, 11),
                        },
                       ],
                      },
                      to: Variable {
                       identifier: "false",
                       position: (554, 20),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "command",
                         position: (555, 11),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "pipe",
                         position: (555, 22),
                        },
                       ],
                       position: (555, 21),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "args",
                         position: (556, 11),
                        },
                       ],
                      },
                      to: List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "flags=hqRu",
                           position: (557, 14),
                          },
                         ],
                         position: (557, 13),
                        },
                        String {
                         parts: [
                          Raw {
                           content: "user=",
                           position: (558, 14),
                          },
                          Expression {
                           expression: Variable {
                            identifier: "user",
                            position: (558, 21),
                           },
                          },
                         ],
                         position: (558, 13),
                        },
                        String {
                         parts: [
                          Raw {
                           content: "argv=",
                           position: (559, 14),
                          },
                          Expression {
                           expression: Variable {
                            identifier: "pkg",
                            position: (559, 21),
                           },
                          },
                          Raw {
                           content: "/libexec/bouncequeue",
                           position: (559, 25),
                          },
                         ],
                         position: (559, 13),
                        },
                        String {
                         parts: [
                          Raw {
                           content: "${nexthop}",
                           position: (560, 14),
                          },
                         ],
                         position: (560, 13),
                        },
                       ],
                       position: (556, 18),
                      },
                     },
                    ],
                    recursive: false,
                    position: (551, 25),
                   },
                  },
                 ],
                 recursive: false,
                 position: (538, 22),
                },
               },
              ],
              recursive: false,
              position: (522, 57),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "services",
              position: (566, 5),
             },
             Raw {
              content: "mysql",
              position: (566, 14),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "optionalAttrs",
             position: (566, 22),
            },
            arguments: [
             Variable {
              identifier: "mysqlLocal",
              position: (566, 36),
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "enable",
                   position: (567, 7),
                  },
                 ],
                },
                to: Variable {
                 identifier: "true",
                 position: (567, 16),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "package",
                   position: (568, 7),
                  },
                 ],
                },
                to: FunctionApplication {
                 function: Variable {
                  identifier: "mkDefault",
                  position: (568, 17),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (568, 27),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "mariadb",
                      position: (568, 32),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "ensureDatabases",
                   position: (569, 7),
                  },
                 ],
                },
                to: List {
                 elements: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (569, 27),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "database",
                      position: (569, 31),
                     },
                     Raw {
                      content: "name",
                      position: (569, 40),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (569, 25),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "ensureUsers",
                   position: (570, 7),
                  },
                 ],
                },
                to: List {
                 elements: [
                  Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "name",
                        position: (571, 11),
                       },
                      ],
                     },
                     to: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (571, 18),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "database",
                         position: (571, 22),
                        },
                        Raw {
                         content: "user",
                         position: (571, 31),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "ensurePermissions",
                        position: (572, 11),
                       },
                      ],
                     },
                     to: Map {
                      bindings: [
                       Binding {
                        from: AttributePath {
                         parts: [
                          Expression {
                           expression: String {
                            parts: [
                             Expression {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "cfg",
                                position: (572, 36),
                               },
                               attribute_path: AttributePath {
                                parts: [
                                 Raw {
                                  content: "database",
                                  position: (572, 40),
                                 },
                                 Raw {
                                  content: "name",
                                  position: (572, 49),
                                 },
                                ],
                               },
                               default: None,
                              },
                             },
                             Raw {
                              content: ".*",
                              position: (572, 54),
                             },
                            ],
                            position: (572, 33),
                           },
                          },
                         ],
                        },
                        to: String {
                         parts: [
                          Raw {
                           content: "ALL PRIVILEGES",
                           position: (572, 61),
                          },
                         ],
                         position: (572, 60),
                        },
                       },
                      ],
                      recursive: false,
                      position: (572, 31),
                     },
                    },
                   ],
                   recursive: false,
                   position: (571, 9),
                  },
                 ],
                 position: (570, 21),
                },
               },
              ],
              recursive: false,
              position: (566, 47),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "services",
              position: (577, 5),
             },
             Raw {
              content: "postgresql",
              position: (577, 14),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "optionalAttrs",
             position: (577, 27),
            },
            arguments: [
             Variable {
              identifier: "pgsqlLocal",
              position: (577, 41),
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "enable",
                   position: (578, 7),
                  },
                 ],
                },
                to: Variable {
                 identifier: "true",
                 position: (578, 16),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "ensureDatabases",
                   position: (579, 7),
                  },
                 ],
                },
                to: List {
                 elements: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (579, 27),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "database",
                      position: (579, 31),
                     },
                     Raw {
                      content: "name",
                      position: (579, 40),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (579, 25),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "ensureUsers",
                   position: (580, 7),
                  },
                 ],
                },
                to: List {
                 elements: [
                  Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "name",
                        position: (581, 11),
                       },
                      ],
                     },
                     to: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (581, 18),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "database",
                         position: (581, 22),
                        },
                        Raw {
                         content: "user",
                         position: (581, 31),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "ensurePermissions",
                        position: (582, 11),
                       },
                      ],
                     },
                     to: Map {
                      bindings: [
                       Binding {
                        from: AttributePath {
                         parts: [
                          Expression {
                           expression: String {
                            parts: [
                             Raw {
                              content: "DATABASE ",
                              position: (582, 34),
                             },
                             Expression {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "cfg",
                                position: (582, 45),
                               },
                               attribute_path: AttributePath {
                                parts: [
                                 Raw {
                                  content: "database",
                                  position: (582, 49),
                                 },
                                 Raw {
                                  content: "name",
                                  position: (582, 58),
                                 },
                                ],
                               },
                               default: None,
                              },
                             },
                            ],
                            position: (582, 33),
                           },
                          },
                         ],
                        },
                        to: String {
                         parts: [
                          Raw {
                           content: "ALL PRIVILEGES",
                           position: (582, 68),
                          },
                         ],
                         position: (582, 67),
                        },
                       },
                      ],
                      recursive: false,
                      position: (582, 31),
                     },
                    },
                   ],
                   recursive: false,
                   position: (581, 9),
                  },
                 ],
                 position: (580, 21),
                },
               },
              ],
              recursive: false,
              position: (577, 52),
             },
            ],
           },
          },
         ],
         recursive: false,
         position: (330, 28),
        },
       ],
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "meta",
         position: (589, 3),
        },
        Raw {
         content: "maintainers",
         position: (589, 8),
        },
       ],
      },
      to: 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),
}