---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (3, 6),
  },
  target: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cfg",
        position: (7, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (7, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (7, 16),
        },
        Raw {
         content: "mailman",
         position: (7, 25),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "pythonEnv",
        position: (9, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (9, 15),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "python3",
          position: (9, 20),
         },
         Raw {
          content: "withPackages",
          position: (9, 28),
         },
        ],
       },
       default: None,
      },
      arguments: [
       Function {
        argument: Some(
         "ps",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: BinaryOperation {
         operator: Concatenation,
         operands: [
          List {
           elements: [
            PropertyAccess {
             expression: Variable {
              identifier: "ps",
              position: (10, 6),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "mailman",
                position: (10, 9),
               },
              ],
             },
             default: None,
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ps",
              position: (10, 17),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "mailman-web",
                position: (10, 20),
               },
              ],
             },
             default: None,
            },
           ],
           position: (10, 5),
          },
          BinaryOperation {
           operator: Concatenation,
           operands: [
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "lib",
               position: (11, 8),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "optional",
                 position: (11, 12),
                },
               ],
              },
              default: None,
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (11, 21),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "hyperkitty",
                  position: (11, 25),
                 },
                 Raw {
                  content: "enable",
                  position: (11, 36),
                 },
                ],
               },
               default: None,
              },
              PropertyAccess {
               expression: Variable {
                identifier: "ps",
                position: (11, 43),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "mailman-hyperkitty",
                  position: (11, 46),
                 },
                ],
               },
               default: None,
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (12, 8),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "extraPythonPackages",
                position: (12, 12),
               },
              ],
             },
             default: None,
            },
           ],
           position: (12, 5),
          },
         ],
         position: (11, 5),
        },
        position: (9, 42),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "webSettings",
        position: (16, 3),
       },
      ],
     },
     BinaryOperation {
      operator: Update,
      operands: [
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "DEFAULT_FROM_EMAIL",
             position: (17, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (17, 26),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "siteOwner",
              position: (17, 30),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "SERVER_EMAIL",
             position: (18, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (18, 20),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "siteOwner",
              position: (18, 24),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "ALLOWED_HOSTS",
             position: (19, 5),
            },
           ],
          },
          BinaryOperation {
           operator: Concatenation,
           operands: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "localhost",
                 position: (19, 24),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "127.0.0.1",
                 position: (19, 36),
                },
               ],
              },
             ],
             position: (19, 21),
            },
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (19, 52),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "webHosts",
                position: (19, 56),
               },
              ],
             },
             default: None,
            },
           ],
           position: (19, 49),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "COMPRESS_OFFLINE",
             position: (20, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (20, 24),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "STATIC_ROOT",
             position: (21, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "/var/lib/mailman-web-static",
             position: (21, 20),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "MEDIA_ROOT",
             position: (22, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "/var/lib/mailman-web/media",
             position: (22, 19),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "LOGGING",
             position: (23, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "version",
                position: (24, 7),
               },
              ],
             },
             Int {
              value: 1,
              position: (24, 17),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "disable_existing_loggers",
                position: (25, 7),
               },
              ],
             },
             Variable {
              identifier: "true",
              position: (25, 34),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "handlers",
                position: (26, 7),
               },
               Raw {
                content: "console",
                position: (26, 16),
               },
               Raw {
                content: "class",
                position: (26, 24),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "logging.StreamHandler",
                position: (26, 33),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "loggers",
                position: (27, 7),
               },
               Raw {
                content: "django",
                position: (27, 15),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "handlers",
                   position: (28, 9),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "console",
                     position: (28, 23),
                    },
                   ],
                  },
                 ],
                 position: (28, 20),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "level",
                   position: (29, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "INFO",
                   position: (29, 18),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (27, 24),
             },
            ),
           ],
           recursive: false,
           position: (23, 15),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "HAYSTACK_CONNECTIONS",
             position: (32, 5),
            },
            Raw {
             content: "default",
             position: (32, 26),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "ENGINE",
                position: (33, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "haystack.backends.whoosh_backend.WhooshEngine",
                position: (33, 17),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "PATH",
                position: (34, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "/var/lib/mailman-web/fulltext-index",
                position: (34, 15),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (32, 36),
          },
         ),
        ],
        recursive: false,
        position: (16, 17),
       },
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (36, 8),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "webSettings",
           position: (36, 12),
          },
         ],
        },
        default: None,
       },
      ],
      position: (36, 5),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "webSettingsJSON",
        position: (38, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (38, 21),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (38, 26),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "settings.json",
          position: (38, 37),
         },
        ],
       },
       FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "builtins",
          position: (38, 53),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "toJSON",
            position: (38, 62),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Variable {
          identifier: "webSettings",
          position: (38, 69),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "postfixMtaConfig",
        position: (41, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (41, 22),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (41, 27),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "mailman-postfix.cfg",
          position: (41, 38),
         },
        ],
       },
       String {
        parts: [
         Raw {
          content: "[postfix]\npostmap_command: ",
          position: (42, 1),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "pkgs",
            position: (43, 24),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "postfix",
              position: (43, 29),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "/bin/postmap\ntransport_file_type: hash\n",
          position: (43, 37),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mailmanCfg",
        position: (47, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "lib",
        position: (47, 16),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "generators",
          position: (47, 20),
         },
         Raw {
          content: "toINI",
          position: (47, 31),
         },
        ],
       },
       default: None,
      },
      arguments: [
       Map {
        bindings: [],
        recursive: false,
        position: (47, 37),
       },
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (47, 40),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "settings",
           position: (47, 44),
          },
         ],
        },
        default: None,
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mailmanHyperkittyCfg",
        position: (49, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (49, 26),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (49, 31),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "mailman-hyperkitty.cfg",
          position: (49, 42),
         },
        ],
       },
       String {
        parts: [
         Raw {
          content: "[general]\n# This is your HyperKitty installation, preferably on the localhost. This\n# address will be used by Mailman to forward incoming emails to HyperKitty\n# for archiving. It does not need to be publicly available, in fact it's\n# better if it is not.\nbase_url: ",
          position: (50, 1),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (55, 17),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "hyperkitty",
              position: (55, 21),
             },
             Raw {
              content: "baseUrl",
              position: (55, 32),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\n\n# Shared API key, must be the identical to the value in HyperKitty's\n# settings.\napi_key: @API_KEY@\n",
          position: (55, 40),
         },
        ],
       },
      ],
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "imports",
         position: (66, 3),
        },
       ],
      },
      List {
       elements: [
        FunctionApplication {
         function: Variable {
          identifier: "mkRenamedOptionModule",
          position: (67, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (67, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "mailman",
               position: (67, 42),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "hyperkittyBaseUrl",
               position: (67, 52),
              },
             ],
            },
           ],
           position: (67, 28),
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (68, 10),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "mailman",
               position: (68, 21),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "hyperkitty",
               position: (68, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "baseUrl",
               position: (68, 44),
              },
             ],
            },
           ],
           position: (68, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (70, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (70, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "mailman",
               position: (70, 42),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "hyperkittyApiKey",
               position: (70, 52),
              },
             ],
            },
           ],
           position: (70, 28),
          },
          String {
           parts: [
            Raw {
             content: "The Hyperkitty API key is now generated on first run, and not\nstored in the world-readable Nix store.  To continue using\nHyperkitty, you must set services.mailman.hyperkitty.enable = true.\n",
             position: (71, 1),
            },
           ],
          },
         ],
        },
       ],
       position: (66, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (77, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "services",
            position: (79, 5),
           },
           Raw {
            content: "mailman",
            position: (79, 14),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (81, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (81, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (82, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (82, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (82, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (83, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (83, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (84, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Enable Mailman on this host. Requires an active MTA on the host (e.g. Postfix).",
                    position: (84, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (81, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "package",
               position: (87, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (87, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (88, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (88, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (88, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (89, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (89, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "mailman",
                     position: (89, 24),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (90, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (90, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.mailman",
                      position: (90, 42),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (91, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (91, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.mailman.override { archivers = []; }",
                      position: (91, 38),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (92, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Mailman package to use",
                    position: (92, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (87, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enablePostfix",
               position: (95, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (95, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (96, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (96, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (96, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (97, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (97, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (98, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (98, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (99, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Enable Postfix integration. Requires an active Postfix installation.\n\nIf you want to use another MTA, set this option to false and configure\nsettings in services.mailman.settings.mta.\n\nRefer to the Mailman manual for more info.\n",
                    position: (100, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (95, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "siteOwner",
               position: (109, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (109, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (110, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (110, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (110, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (111, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "postmaster@example.org",
                    position: (111, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (112, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Certain messages that must be delivered to a human, but which can't\nbe delivered to a list owner (e.g. a bounce from a list owner), will\nbe sent to this address. It should point to a human.\n",
                    position: (113, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (109, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "webHosts",
               position: (119, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (119, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (120, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (120, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (120, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (120, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (120, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (121, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (121, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (122, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The list of hostnames and/or IP addresses from which the Mailman Web\nUI will accept requests. By default, \"localhost\" and \"127.0.0.1\" are\nenabled. All additional names under which your web server accepts\nrequests for the UI must be listed here or incoming requests will be\nrejected.\n",
                    position: (123, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (119, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "webUser",
               position: (131, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (131, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (132, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (132, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (132, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (133, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "mailman-web",
                    position: (133, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (134, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "User to run mailman-web as\n",
                    position: (135, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (131, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "webSettings",
               position: (139, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (139, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (140, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (140, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "attrs",
                     position: (140, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (141, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (141, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (142, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Overrides for the default mailman-web Django settings.\n",
                    position: (143, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (139, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "serve",
               position: (147, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "enable",
                  position: (148, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkEnableOption",
                 position: (148, 18),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "Automatic nginx and uwsgi setup for mailman-web",
                    position: (148, 34),
                   },
                  ],
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (147, 15),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraPythonPackages",
               position: (151, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (151, 29),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (152, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Packages to add to the python environment used by mailman and mailman-web",
                    position: (152, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (153, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (153, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (153, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (153, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "package",
                       position: (153, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (154, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (154, 19),
                 },
                ),
               ],
               recursive: false,
               position: (151, 38),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "settings",
               position: (157, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (157, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (158, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Settings for mailman.cfg",
                    position: (158, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (159, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (159, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "attrsOf",
                      position: (159, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (159, 31),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "attrsOf",
                        position: (159, 37),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (159, 45),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "str",
                         position: (159, 51),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (160, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (160, 19),
                 },
                ),
               ],
               recursive: false,
               position: (157, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "hyperkitty",
               position: (163, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "enable",
                  position: (164, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkEnableOption",
                 position: (164, 18),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "the Hyperkitty archiver for Mailman",
                    position: (164, 34),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "baseUrl",
                  position: (166, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (166, 19),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (167, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (167, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (167, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (168, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "http://localhost:18507/archives/",
                       position: (168, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (169, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Where can Mailman connect to Hyperkitty's internal API, preferably on\nlocalhost?\n",
                       position: (170, 1),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (166, 28),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (163, 20),
            },
           ),
          ],
          recursive: false,
          position: (79, 24),
         },
        ),
       ],
       recursive: false,
       position: (77, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (181, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (181, 12),
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (181, 17),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (181, 21),
           },
          ],
         },
         default: None,
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (183, 5),
             },
             Raw {
              content: "mailman",
              position: (183, 14),
             },
             Raw {
              content: "settings",
              position: (183, 22),
             },
            ],
           },
           BinaryOperation {
            operator: Update,
            operands: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "mailman",
                   position: (184, 7),
                  },
                  Raw {
                   content: "site_owner",
                   position: (184, 15),
                  },
                 ],
                },
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "lib",
                   position: (184, 28),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "mkDefault",
                     position: (184, 32),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (184, 42),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "siteOwner",
                      position: (184, 46),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "mailman",
                   position: (185, 7),
                  },
                  Raw {
                   content: "layout",
                   position: (185, 15),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "fhs",
                   position: (185, 25),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Expression {
                   expression: String {
                    parts: [
                     Raw {
                      content: "paths.fhs",
                      position: (187, 8),
                     },
                    ],
                   },
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bin_dir",
                      position: (188, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (188, 22),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "python3Packages",
                          position: (188, 27),
                         },
                         Raw {
                          content: "mailman",
                          position: (188, 43),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/bin",
                      position: (188, 51),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "var_dir",
                      position: (189, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "/var/lib/mailman",
                      position: (189, 20),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "queue_dir",
                      position: (190, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "$var_dir/queue",
                      position: (190, 22),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "template_dir",
                      position: (191, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "$var_dir/templates",
                      position: (191, 25),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "log_dir",
                      position: (192, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "/var/log/mailman",
                      position: (192, 20),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "lock_dir",
                      position: (193, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "$var_dir/lock",
                      position: (193, 21),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "etc_dir",
                      position: (194, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "/etc",
                      position: (194, 20),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "ext_dir",
                      position: (195, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "$etc_dir/mailman.d",
                      position: (195, 20),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "pid_file",
                      position: (196, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "/run/mailman/master.pid",
                      position: (196, 21),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (187, 21),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "mta",
                   position: (199, 7),
                  },
                  Raw {
                   content: "configuration",
                   position: (199, 11),
                  },
                 ],
                },
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "lib",
                   position: (199, 27),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "mkDefault",
                     position: (199, 31),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  IfThenElse {
                   predicate: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (199, 45),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "enablePostfix",
                       position: (199, 49),
                      },
                     ],
                    },
                    default: None,
                   },
                   then: String {
                    parts: [
                     Expression {
                      expression: Variable {
                       identifier: "postfixMtaConfig",
                       position: (199, 71),
                      },
                     },
                    ],
                   },
                   else_: FunctionApplication {
                    function: Variable {
                     identifier: "throw",
                     position: (199, 95),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "When Mailman Postfix integration is disabled, set `services.mailman.settings.mta.configuration` to the path of the config file required to integrate with your MTA.",
                        position: (199, 102),
                       },
                      ],
                     },
                    ],
                   },
                   position: (199, 42),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Expression {
                   expression: String {
                    parts: [
                     Raw {
                      content: "archiver.hyperkitty",
                      position: (201, 8),
                     },
                    ],
                   },
                  },
                 ],
                },
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "lib",
                   position: (201, 31),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "mkIf",
                     position: (201, 35),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (201, 40),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "hyperkitty",
                      position: (201, 44),
                     },
                     Raw {
                      content: "enable",
                      position: (201, 55),
                     },
                    ],
                   },
                   default: None,
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "class",
                        position: (202, 9),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "mailman_hyperkitty.Archiver",
                        position: (202, 18),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "enable",
                        position: (203, 9),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "yes",
                        position: (203, 19),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "configuration",
                        position: (204, 9),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "/var/lib/mailman/mailman-hyperkitty.cfg",
                        position: (204, 26),
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (201, 62),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (183, 33),
             },
             LetIn {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "loggerNames",
                   position: (207, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "root",
                     position: (207, 23),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "archiver",
                     position: (207, 30),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "bounce",
                     position: (207, 41),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "config",
                     position: (207, 50),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "database",
                     position: (207, 59),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "debug",
                     position: (207, 70),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "error",
                     position: (207, 78),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "fromusenet",
                     position: (207, 86),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "http",
                     position: (207, 99),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "locks",
                     position: (207, 106),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "mischief",
                     position: (207, 114),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "plugins",
                     position: (207, 125),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "runner",
                     position: (207, 135),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "smtp",
                     position: (207, 144),
                    },
                   ],
                  },
                 ],
                 position: (207, 21),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "loggerSectionNames",
                   position: (208, 7),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "map",
                  position: (208, 28),
                 },
                 arguments: [
                  Function {
                   argument: Some(
                    "n",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: String {
                    parts: [
                     Raw {
                      content: "logging.",
                      position: (208, 37),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "n",
                       position: (208, 47),
                      },
                     },
                    ],
                   },
                   position: (208, 33),
                  },
                  Variable {
                   identifier: "loggerNames",
                   position: (208, 52),
                  },
                 ],
                },
               ),
              ],
              target: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (209, 10),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "genAttrs",
                   position: (209, 14),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Variable {
                 identifier: "loggerSectionNames",
                 position: (209, 23),
                },
                Function {
                 argument: Some(
                  "name",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "handler",
                       position: (209, 50),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "stderr",
                       position: (209, 61),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (209, 48),
                 },
                 position: (209, 42),
                },
               ],
              },
              position: (206, 11),
             },
            ],
            position: (206, 7),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "assertions",
              position: (212, 5),
             },
            ],
           },
           LetIn {
            bindings: [
             Inherit(
              Some(
               PropertyAccess {
                expression: Variable {
                 identifier: "config",
                 position: (213, 16),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "services",
                   position: (213, 23),
                  },
                 ],
                },
                default: None,
               },
              ),
              [
               Raw {
                content: "postfix",
                position: (213, 33),
               },
              ],
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "requirePostfixHash",
                 position: (215, 7),
                },
               ],
              },
              Function {
               argument: Some(
                "optionPath",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: Function {
                argument: Some(
                 "dataFile",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: With {
                 expression: Variable {
                  identifier: "lib",
                  position: (216, 14),
                 },
                 target: LetIn {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "expected",
                       position: (218, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "hash:/var/lib/mailman/data/",
                       position: (218, 23),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "dataFile",
                        position: (218, 52),
                       },
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "value",
                       position: (219, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "attrByPath",
                      position: (219, 19),
                     },
                     arguments: [
                      Variable {
                       identifier: "optionPath",
                       position: (219, 30),
                      },
                      List {
                       elements: [],
                       position: (219, 41),
                      },
                      Variable {
                       identifier: "postfix",
                       position: (219, 44),
                      },
                     ],
                    },
                   ),
                  ],
                  target: Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "assertion",
                        position: (221, 13),
                       },
                      ],
                     },
                     BinaryOperation {
                      operator: Implication,
                      operands: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "postfix",
                         position: (221, 25),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "enable",
                           position: (221, 33),
                          },
                         ],
                        },
                        default: None,
                       },
                       BinaryOperation {
                        operator: LogicalAnd,
                        operands: [
                         FunctionApplication {
                          function: Variable {
                           identifier: "isList",
                           position: (221, 43),
                          },
                          arguments: [
                           Variable {
                            identifier: "value",
                            position: (221, 50),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "elem",
                           position: (221, 59),
                          },
                          arguments: [
                           Variable {
                            identifier: "expected",
                            position: (221, 64),
                           },
                           Variable {
                            identifier: "value",
                            position: (221, 73),
                           },
                          ],
                         },
                        ],
                        position: (221, 56),
                       },
                      ],
                      position: (221, 40),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "message",
                        position: (222, 13),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "services.postfix.",
                        position: (223, 1),
                       },
                       Expression {
                        expression: FunctionApplication {
                         function: Variable {
                          identifier: "concatStringsSep",
                          position: (223, 34),
                         },
                         arguments: [
                          String {
                           parts: [
                            Raw {
                             content: ".",
                             position: (223, 52),
                            },
                           ],
                          },
                          Variable {
                           identifier: "optionPath",
                           position: (223, 55),
                          },
                         ],
                        },
                       },
                       Raw {
                        content: " must contain\n\"",
                        position: (223, 66),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "expected",
                         position: (224, 18),
                        },
                       },
                       Raw {
                        content: "\".\nSee <https://mailman.readthedocs.io/en/latest/src/mailman/docs/mta.html>.\n",
                        position: (224, 27),
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (221, 11),
                  },
                  position: (217, 9),
                 },
                 position: (216, 9),
                },
                position: (215, 40),
               },
               position: (215, 28),
              },
             ),
            ],
            target: FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "lib",
               position: (228, 9),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "optionals",
                 position: (228, 13),
                },
               ],
              },
              default: None,
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (228, 23),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "enablePostfix",
                  position: (228, 27),
                 },
                ],
               },
               default: None,
              },
              List {
               elements: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "assertion",
                      position: (229, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "postfix",
                     position: (229, 21),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "enable",
                       position: (229, 29),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "message",
                      position: (230, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Mailman's default NixOS configuration requires Postfix to be enabled.\n\nIf you want to use another MTA, set services.mailman.enablePostfix\nto false and configure settings in services.mailman.settings.mta.\n\nRefer to <https://mailman.readthedocs.io/en/latest/src/mailman/docs/mta.html>\nfor more info.\n",
                      position: (231, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (229, 7),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "requirePostfixHash",
                  position: (240, 8),
                 },
                 arguments: [
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "relayDomains",
                       position: (240, 30),
                      },
                     ],
                    },
                   ],
                   position: (240, 27),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "postfix_domains",
                     position: (240, 47),
                    },
                   ],
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "requirePostfixHash",
                  position: (241, 8),
                 },
                 arguments: [
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "config",
                       position: (241, 30),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "transport_maps",
                       position: (241, 39),
                      },
                     ],
                    },
                   ],
                   position: (241, 27),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "postfix_lmtp",
                     position: (241, 58),
                    },
                   ],
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "requirePostfixHash",
                  position: (242, 8),
                 },
                 arguments: [
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "config",
                       position: (242, 30),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "local_recipient_maps",
                       position: (242, 39),
                      },
                     ],
                    },
                   ],
                   position: (242, 27),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "postfix_lmtp",
                     position: (242, 64),
                    },
                   ],
                  },
                 ],
                },
               ],
               position: (228, 41),
              },
             ],
            },
            position: (212, 18),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (245, 5),
             },
             Raw {
              content: "users",
              position: (245, 11),
             },
             Raw {
              content: "mailman",
              position: (245, 17),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (246, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "GNU Mailman",
                 position: (246, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "isSystemUser",
                 position: (247, 7),
                },
               ],
              },
              Variable {
               identifier: "true",
               position: (247, 22),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "group",
                 position: (248, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "mailman",
                 position: (248, 16),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (245, 27),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (250, 5),
             },
             Raw {
              content: "users",
              position: (250, 11),
             },
             Raw {
              content: "mailman-web",
              position: (250, 17),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "lib",
              position: (250, 31),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "mkIf",
                position: (250, 35),
               },
              ],
             },
             default: None,
            },
            arguments: [
             BinaryOperation {
              operator: EqualTo,
              operands: [
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (250, 41),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "webUser",
                   position: (250, 45),
                  },
                 ],
                },
                default: None,
               },
               String {
                parts: [
                 Raw {
                  content: "mailman-web",
                  position: (250, 57),
                 },
                ],
               },
              ],
              position: (250, 53),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (251, 7),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "GNU Mailman web interface",
                   position: (251, 22),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "isSystemUser",
                   position: (252, 7),
                  },
                 ],
                },
                Variable {
                 identifier: "true",
                 position: (252, 22),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "group",
                   position: (253, 7),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "mailman",
                   position: (253, 16),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (250, 71),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (255, 5),
             },
             Raw {
              content: "groups",
              position: (255, 11),
             },
             Raw {
              content: "mailman",
              position: (255, 18),
             },
            ],
           },
           Map {
            bindings: [],
            recursive: false,
            position: (255, 28),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (257, 5),
             },
             Raw {
              content: "etc",
              position: (257, 17),
             },
             Expression {
              expression: String {
               parts: [
                Raw {
                 content: "mailman.cfg",
                 position: (257, 22),
                },
               ],
              },
             },
             Raw {
              content: "text",
              position: (257, 35),
             },
            ],
           },
           Variable {
            identifier: "mailmanCfg",
            position: (257, 42),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (259, 5),
             },
             Raw {
              content: "etc",
              position: (259, 17),
             },
             Expression {
              expression: String {
               parts: [
                Raw {
                 content: "mailman3/settings.py",
                 position: (259, 22),
                },
               ],
              },
             },
             Raw {
              content: "text",
              position: (259, 44),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "import os\n\n# Required by mailman_web.settings, but will be overridden when\n# settings_local.json is loaded.\nos.environ[\"SECRET_KEY\"] = \"\"\n\nfrom mailman_web.settings.base import *\nfrom mailman_web.settings.mailman import *\n\nimport json\n\nwith open(",
              position: (260, 1),
             },
             Raw {
              content: "'",
              position: (271, 17),
             },
             Expression {
              expression: Variable {
               identifier: "webSettingsJSON",
               position: (271, 20),
              },
             },
             Raw {
              content: "') as f:\n    globals().update(json.load(f))\n\nwith open('/var/lib/mailman-web/settings_local.json') as f:\n    globals().update(json.load(f))\n",
              position: (271, 36),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (278, 5),
             },
             Raw {
              content: "nginx",
              position: (278, 14),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (278, 22),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (278, 27),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "serve",
                 position: (278, 31),
                },
                Raw {
                 content: "enable",
                 position: (278, 37),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "enable",
                   position: (279, 7),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mkDefault",
                  position: (279, 16),
                 },
                 arguments: [
                  Variable {
                   identifier: "true",
                   position: (279, 26),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "virtualHosts",
                   position: (280, 7),
                  },
                  Expression {
                   expression: String {
                    parts: [
                     Expression {
                      expression: FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "lib",
                         position: (280, 23),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "head",
                           position: (280, 27),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (280, 32),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "webHosts",
                            position: (280, 36),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                      },
                     },
                    ],
                   },
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "serverAliases",
                      position: (281, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (281, 25),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "webHosts",
                       position: (281, 29),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "locations",
                      position: (282, 9),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Expression {
                         expression: String {
                          parts: [
                           Raw {
                            content: "/",
                            position: (283, 12),
                           },
                          ],
                         },
                        },
                        Raw {
                         content: "extraConfig",
                         position: (283, 15),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "uwsgi_pass unix:/run/mailman-web.socket;",
                         position: (283, 30),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Expression {
                         expression: String {
                          parts: [
                           Raw {
                            content: "/static/",
                            position: (284, 12),
                           },
                          ],
                         },
                        },
                        Raw {
                         content: "alias",
                         position: (284, 22),
                        },
                       ],
                      },
                      BinaryOperation {
                       operator: Addition,
                       operands: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "webSettings",
                          position: (284, 30),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "STATIC_ROOT",
                            position: (284, 42),
                           },
                          ],
                         },
                         default: None,
                        },
                        String {
                         parts: [
                          Raw {
                           content: "/",
                           position: (284, 57),
                          },
                         ],
                        },
                       ],
                       position: (284, 54),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (282, 21),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (280, 49),
                },
               ),
              ],
              recursive: false,
              position: (278, 44),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (289, 5),
             },
             Raw {
              content: "systemPackages",
              position: (289, 17),
             },
            ],
           },
           List {
            elements: [
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "pkgs",
                position: (289, 37),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "buildEnv",
                  position: (289, 42),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "name",
                     position: (290, 7),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "mailman-tools",
                     position: (290, 15),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "pathsToLink",
                     position: (294, 7),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "/bin",
                       position: (294, 23),
                      },
                     ],
                    },
                   ],
                   position: (294, 21),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "paths",
                     position: (295, 7),
                    },
                   ],
                  },
                  List {
                   elements: [
                    Variable {
                     identifier: "pythonEnv",
                     position: (295, 16),
                    },
                   ],
                   position: (295, 15),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "postBuild",
                     position: (296, 7),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "find $out/bin/ -mindepth 1 -not -name \"mailman*\" -delete\n",
                     position: (297, 1),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (289, 51),
               },
              ],
             },
            ],
            position: (289, 34),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (301, 5),
             },
             Raw {
              content: "postfix",
              position: (301, 14),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "lib",
              position: (301, 24),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "mkIf",
                position: (301, 28),
               },
              ],
             },
             default: None,
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (301, 33),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "enablePostfix",
                 position: (301, 37),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "recipientDelimiter",
                   position: (302, 7),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "+",
                   position: (302, 29),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "config",
                   position: (303, 7),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "owner_request_special",
                      position: (304, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "no",
                      position: (304, 34),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (303, 16),
                },
               ),
              ],
              recursive: false,
              position: (301, 51),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (308, 5),
             },
             Raw {
              content: "sockets",
              position: (308, 13),
             },
             Raw {
              content: "mailman-uwsgi",
              position: (308, 21),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "lib",
              position: (308, 37),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "mkIf",
                position: (308, 41),
               },
              ],
             },
             default: None,
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (308, 46),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "serve",
                 position: (308, 50),
                },
                Raw {
                 content: "enable",
                 position: (308, 56),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "wantedBy",
                   position: (309, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "sockets.target",
                     position: (309, 20),
                    },
                   ],
                  },
                 ],
                 position: (309, 18),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "before",
                   position: (310, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "nginx.service",
                     position: (310, 18),
                    },
                   ],
                  },
                 ],
                 position: (310, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "socketConfig",
                   position: (311, 7),
                  },
                  Raw {
                   content: "ListenStream",
                   position: (311, 20),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "/run/mailman-web.socket",
                   position: (311, 36),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (308, 63),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (313, 5),
             },
             Raw {
              content: "services",
              position: (313, 13),
             },
            ],
           },
           BinaryOperation {
            operator: Update,
            operands: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "mailman",
                   position: (314, 7),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (315, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "GNU Mailman Master Process",
                      position: (315, 24),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "after",
                      position: (316, 9),
                     },
                    ],
                   },
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "network.target",
                        position: (316, 20),
                       },
                      ],
                     },
                    ],
                    position: (316, 17),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "restartTriggers",
                      position: (317, 9),
                     },
                    ],
                   },
                   List {
                    elements: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (317, 29),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "environment",
                         position: (317, 36),
                        },
                        Raw {
                         content: "etc",
                         position: (317, 48),
                        },
                        Expression {
                         expression: String {
                          parts: [
                           Raw {
                            content: "mailman.cfg",
                            position: (317, 53),
                           },
                          ],
                         },
                        },
                        Raw {
                         content: "source",
                         position: (317, 66),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                    position: (317, 27),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "wantedBy",
                      position: (318, 9),
                     },
                    ],
                   },
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "multi-user.target",
                        position: (318, 23),
                       },
                      ],
                     },
                    ],
                    position: (318, 20),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "serviceConfig",
                      position: (319, 9),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "ExecStart",
                         position: (320, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Expression {
                         expression: Variable {
                          identifier: "pythonEnv",
                          position: (320, 26),
                         },
                        },
                        Raw {
                         content: "/bin/mailman start",
                         position: (320, 36),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "ExecStop",
                         position: (321, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Expression {
                         expression: Variable {
                          identifier: "pythonEnv",
                          position: (321, 25),
                         },
                        },
                        Raw {
                         content: "/bin/mailman stop",
                         position: (321, 35),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "User",
                         position: (322, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "mailman",
                         position: (322, 19),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "Group",
                         position: (323, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "mailman",
                         position: (323, 20),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "Type",
                         position: (324, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "forking",
                         position: (324, 19),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "RuntimeDirectory",
                         position: (325, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "mailman",
                         position: (325, 31),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "LogsDirectory",
                         position: (326, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "mailman",
                         position: (326, 28),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "PIDFile",
                         position: (327, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "/run/mailman/master.pid",
                         position: (327, 22),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (319, 25),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (314, 17),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "mailman-settings",
                   position: (331, 7),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (332, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Generate settings files (including secrets) for Mailman",
                      position: (332, 24),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "before",
                      position: (333, 9),
                     },
                    ],
                   },
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "mailman.service",
                        position: (333, 21),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "mailman-web-setup.service",
                        position: (333, 39),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "mailman-uwsgi.service",
                        position: (333, 67),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "hyperkitty.service",
                        position: (333, 91),
                       },
                      ],
                     },
                    ],
                    position: (333, 18),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "requiredBy",
                      position: (334, 9),
                     },
                    ],
                   },
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "mailman.service",
                        position: (334, 25),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "mailman-web-setup.service",
                        position: (334, 43),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "mailman-uwsgi.service",
                        position: (334, 71),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "hyperkitty.service",
                        position: (334, 95),
                       },
                      ],
                     },
                    ],
                    position: (334, 22),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "path",
                      position: (335, 9),
                     },
                    ],
                   },
                   With {
                    expression: Variable {
                     identifier: "pkgs",
                     position: (335, 21),
                    },
                    target: List {
                     elements: [
                      Variable {
                       identifier: "jq",
                       position: (335, 29),
                      },
                     ],
                     position: (335, 27),
                    },
                    position: (335, 16),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "serviceConfig",
                      position: (336, 9),
                     },
                     Raw {
                      content: "Type",
                      position: (336, 23),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "oneshot",
                      position: (336, 31),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "script",
                      position: (337, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "mailmanDir=/var/lib/mailman\nmailmanWebDir=/var/lib/mailman-web\n\nmailmanCfg=$mailmanDir/mailman-hyperkitty.cfg\nmailmanWebCfg=$mailmanWebDir/settings_local.json\n\ninstall -m 0775 -o mailman -g mailman -d /var/lib/mailman-web-static\ninstall -m 0770 -o mailman -g mailman -d $mailmanDir\ninstall -m 0770 -o ",
                      position: (338, 1),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (346, 32),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "webUser",
                          position: (346, 36),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: " -g mailman -d $mailmanWebDir\n\nif [ ! -e $mailmanWebCfg ]; then\n    hyperkittyApiKey=$(tr -dc A-Za-z0-9 < /dev/urandom | head -c 64)\n    secretKey=$(tr -dc A-Za-z0-9 < /dev/urandom | head -c 64)\n\n    mailmanWebCfgTmp=$(mktemp)\n    jq -n '.MAILMAN_ARCHIVER_KEY=$archiver_key | .SECRET_KEY=$secret_key' \\\n        --arg archiver_key \"$hyperkittyApiKey\" \\\n        --arg secret_key \"$secretKey\" \\\n        >\"$mailmanWebCfgTmp\"\n    chown root:mailman \"$mailmanWebCfgTmp\"\n    chmod 440 \"$mailmanWebCfgTmp\"\n    mv -n \"$mailmanWebCfgTmp\" \"$mailmanWebCfg\"\nfi\n\nhyperkittyApiKey=\"$(jq -r .MAILMAN_ARCHIVER_KEY \"$mailmanWebCfg\")\"\nmailmanCfgTmp=$(mktemp)\nsed \"s/@API_KEY@/$hyperkittyApiKey/g\" ",
                      position: (346, 44),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "mailmanHyperkittyCfg",
                       position: (364, 51),
                      },
                     },
                     Raw {
                      content: " >\"$mailmanCfgTmp\"\nchown mailman:mailman \"$mailmanCfgTmp\"\nmv \"$mailmanCfgTmp\" \"$mailmanCfg\"\n",
                      position: (364, 72),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (331, 26),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "mailman-web-setup",
                   position: (370, 7),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (371, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Prepare mailman-web files and database",
                      position: (371, 24),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "before",
                      position: (372, 9),
                     },
                    ],
                   },
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "mailman-uwsgi.service",
                        position: (372, 21),
                       },
                      ],
                     },
                    ],
                    position: (372, 18),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "requiredBy",
                      position: (373, 9),
                     },
                    ],
                   },
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "mailman-uwsgi.service",
                        position: (373, 25),
                       },
                      ],
                     },
                    ],
                    position: (373, 22),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "restartTriggers",
                      position: (374, 9),
                     },
                    ],
                   },
                   List {
                    elements: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (374, 29),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "environment",
                         position: (374, 36),
                        },
                        Raw {
                         content: "etc",
                         position: (374, 48),
                        },
                        Expression {
                         expression: String {
                          parts: [
                           Raw {
                            content: "mailman3/settings.py",
                            position: (374, 53),
                           },
                          ],
                         },
                        },
                        Raw {
                         content: "source",
                         position: (374, 75),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                    position: (374, 27),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "script",
                      position: (375, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "[[ -e \"",
                      position: (376, 1),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "webSettings",
                        position: (376, 20),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "STATIC_ROOT",
                          position: (376, 32),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "\" ]] && find \"",
                      position: (376, 44),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "webSettings",
                        position: (376, 60),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "STATIC_ROOT",
                          position: (376, 72),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/\" -mindepth 1 -delete\n",
                      position: (376, 84),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "pythonEnv",
                       position: (377, 13),
                      },
                     },
                     Raw {
                      content: "/bin/mailman-web migrate\n",
                      position: (377, 23),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "pythonEnv",
                       position: (378, 13),
                      },
                     },
                     Raw {
                      content: "/bin/mailman-web collectstatic\n",
                      position: (378, 23),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "pythonEnv",
                       position: (379, 13),
                      },
                     },
                     Raw {
                      content: "/bin/mailman-web compress\n",
                      position: (379, 23),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "serviceConfig",
                      position: (381, 9),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "User",
                         position: (382, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (382, 18),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "webUser",
                          position: (382, 22),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "Group",
                         position: (383, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "mailman",
                         position: (383, 20),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "Type",
                         position: (384, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "oneshot",
                         position: (384, 19),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "WorkingDirectory",
                         position: (385, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "/var/lib/mailman-web",
                         position: (385, 31),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (381, 25),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (370, 27),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "mailman-uwsgi",
                   position: (389, 7),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mkIf",
                  position: (389, 23),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (389, 28),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "serve",
                      position: (389, 32),
                     },
                     Raw {
                      content: "enable",
                      position: (389, 38),
                     },
                    ],
                   },
                   default: None,
                  },
                  LetIn {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "uwsgiConfig",
                        position: (390, 9),
                       },
                       Raw {
                        content: "uwsgi",
                        position: (390, 21),
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "type",
                           position: (391, 11),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "normal",
                           position: (391, 19),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "plugins",
                           position: (392, 11),
                          },
                         ],
                        },
                        List {
                         elements: [
                          String {
                           parts: [
                            Raw {
                             content: "python3",
                             position: (392, 23),
                            },
                           ],
                          },
                         ],
                         position: (392, 21),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "home",
                           position: (393, 11),
                          },
                         ],
                        },
                        Variable {
                         identifier: "pythonEnv",
                         position: (393, 18),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "module",
                           position: (394, 11),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "mailman_web.wsgi",
                           position: (394, 21),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "http",
                           position: (395, 11),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "127.0.0.1:18507",
                           position: (395, 19),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (390, 29),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "uwsgiConfigFile",
                        position: (397, 9),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (397, 27),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "writeText",
                          position: (397, 32),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "uwsgi-mailman.json",
                          position: (397, 43),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: PropertyAccess {
                         expression: Variable {
                          identifier: "builtins",
                          position: (397, 64),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "toJSON",
                            position: (397, 73),
                           },
                          ],
                         },
                         default: None,
                        },
                        arguments: [
                         Variable {
                          identifier: "uwsgiConfig",
                          position: (397, 80),
                         },
                        ],
                       },
                      ],
                     },
                    ),
                   ],
                   target: Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "wantedBy",
                         position: (399, 9),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "multi-user.target",
                           position: (399, 22),
                          },
                         ],
                        },
                       ],
                       position: (399, 20),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "requires",
                         position: (400, 9),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "mailman-uwsgi.socket",
                           position: (400, 22),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "mailman-web-setup.service",
                           position: (400, 45),
                          },
                         ],
                        },
                       ],
                       position: (400, 20),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "restartTriggers",
                         position: (401, 9),
                        },
                       ],
                      },
                      List {
                       elements: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "config",
                          position: (401, 29),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "environment",
                            position: (401, 36),
                           },
                           Raw {
                            content: "etc",
                            position: (401, 48),
                           },
                           Expression {
                            expression: String {
                             parts: [
                              Raw {
                               content: "mailman3/settings.py",
                               position: (401, 53),
                              },
                             ],
                            },
                           },
                           Raw {
                            content: "source",
                            position: (401, 75),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                       position: (401, 27),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "serviceConfig",
                         position: (402, 9),
                        },
                       ],
                      },
                      Map {
                       bindings: [
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "ExecStart",
                            position: (406, 11),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Expression {
                            expression: PropertyAccess {
                             expression: Variable {
                              identifier: "pkgs",
                              position: (406, 26),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "coreutils",
                                position: (406, 31),
                               },
                              ],
                             },
                             default: None,
                            },
                           },
                           Raw {
                            content: "/bin/env -C $RUNTIME_DIRECTORY ",
                            position: (406, 41),
                           },
                           Expression {
                            expression: FunctionApplication {
                             function: PropertyAccess {
                              expression: Variable {
                               identifier: "pkgs",
                               position: (406, 74),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "uwsgi",
                                 position: (406, 79),
                                },
                                Raw {
                                 content: "override",
                                 position: (406, 85),
                                },
                               ],
                              },
                              default: None,
                             },
                             arguments: [
                              Map {
                               bindings: [
                                KeyValue(
                                 AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "plugins",
                                    position: (406, 96),
                                   },
                                  ],
                                 },
                                 List {
                                  elements: [
                                   String {
                                    parts: [
                                     Raw {
                                      content: "python3",
                                      position: (406, 108),
                                     },
                                    ],
                                   },
                                  ],
                                  position: (406, 106),
                                 },
                                ),
                               ],
                               recursive: false,
                               position: (406, 94),
                              },
                             ],
                            },
                           },
                           Raw {
                            content: "/bin/uwsgi --json ",
                            position: (406, 121),
                           },
                           Expression {
                            expression: Variable {
                             identifier: "uwsgiConfigFile",
                             position: (406, 141),
                            },
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "User",
                            position: (407, 11),
                           },
                          ],
                         },
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (407, 18),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "webUser",
                             position: (407, 22),
                            },
                           ],
                          },
                          default: None,
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "Group",
                            position: (408, 11),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "mailman",
                            position: (408, 20),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "RuntimeDirectory",
                            position: (409, 11),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "mailman-uwsgi",
                            position: (409, 31),
                           },
                          ],
                         },
                        ),
                       ],
                       recursive: false,
                       position: (402, 25),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (398, 10),
                   },
                   position: (389, 46),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "mailman-daily",
                   position: (413, 7),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (414, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Trigger daily Mailman events",
                      position: (414, 24),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "startAt",
                      position: (415, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "daily",
                      position: (415, 20),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "restartTriggers",
                      position: (416, 9),
                     },
                    ],
                   },
                   List {
                    elements: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (416, 29),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "environment",
                         position: (416, 36),
                        },
                        Raw {
                         content: "etc",
                         position: (416, 48),
                        },
                        Expression {
                         expression: String {
                          parts: [
                           Raw {
                            content: "mailman.cfg",
                            position: (416, 53),
                           },
                          ],
                         },
                        },
                        Raw {
                         content: "source",
                         position: (416, 66),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                    position: (416, 27),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "serviceConfig",
                      position: (417, 9),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "ExecStart",
                         position: (418, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Expression {
                         expression: Variable {
                          identifier: "pythonEnv",
                          position: (418, 26),
                         },
                        },
                        Raw {
                         content: "/bin/mailman digests --send",
                         position: (418, 36),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "User",
                         position: (419, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "mailman",
                         position: (419, 19),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "Group",
                         position: (420, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "mailman",
                         position: (420, 20),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (417, 25),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (413, 23),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "hyperkitty",
                   position: (424, 7),
                  },
                 ],
                },
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "lib",
                   position: (424, 20),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "mkIf",
                     position: (424, 24),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (424, 29),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "hyperkitty",
                      position: (424, 33),
                     },
                     Raw {
                      content: "enable",
                      position: (424, 44),
                     },
                    ],
                   },
                   default: None,
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "description",
                        position: (425, 9),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "GNU Hyperkitty QCluster Process",
                        position: (425, 24),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "after",
                        position: (426, 9),
                       },
                      ],
                     },
                     List {
                      elements: [
                       String {
                        parts: [
                         Raw {
                          content: "network.target",
                          position: (426, 20),
                         },
                        ],
                       },
                      ],
                      position: (426, 17),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "restartTriggers",
                        position: (427, 9),
                       },
                      ],
                     },
                     List {
                      elements: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "config",
                         position: (427, 29),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "environment",
                           position: (427, 36),
                          },
                          Raw {
                           content: "etc",
                           position: (427, 48),
                          },
                          Expression {
                           expression: String {
                            parts: [
                             Raw {
                              content: "mailman3/settings.py",
                              position: (427, 53),
                             },
                            ],
                           },
                          },
                          Raw {
                           content: "source",
                           position: (427, 75),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                      position: (427, 27),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "wantedBy",
                        position: (428, 9),
                       },
                      ],
                     },
                     List {
                      elements: [
                       String {
                        parts: [
                         Raw {
                          content: "mailman.service",
                          position: (428, 23),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "multi-user.target",
                          position: (428, 41),
                         },
                        ],
                       },
                      ],
                      position: (428, 20),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "serviceConfig",
                        position: (429, 9),
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "ExecStart",
                           position: (430, 11),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Expression {
                           expression: Variable {
                            identifier: "pythonEnv",
                            position: (430, 26),
                           },
                          },
                          Raw {
                           content: "/bin/mailman-web qcluster",
                           position: (430, 36),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "User",
                           position: (431, 11),
                          },
                         ],
                        },
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (431, 18),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "webUser",
                            position: (431, 22),
                           },
                          ],
                         },
                         default: None,
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "Group",
                           position: (432, 11),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "mailman",
                           position: (432, 20),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "WorkingDirectory",
                           position: (433, 11),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "/var/lib/mailman-web",
                           position: (433, 31),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (429, 25),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (424, 51),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (313, 24),
             },
             FunctionApplication {
              function: Variable {
               identifier: "flip",
               position: (436, 10),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (436, 15),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "mapAttrs'",
                   position: (436, 19),
                  },
                 ],
                },
                default: None,
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Expression {
                     expression: String {
                      parts: [
                       Raw {
                        content: "minutely",
                        position: (437, 8),
                       },
                      ],
                     },
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "minutely",
                     position: (437, 21),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Expression {
                     expression: String {
                      parts: [
                       Raw {
                        content: "quarter_hourly",
                        position: (438, 8),
                       },
                      ],
                     },
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "*:00/15",
                     position: (438, 27),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Expression {
                     expression: String {
                      parts: [
                       Raw {
                        content: "hourly",
                        position: (439, 8),
                       },
                      ],
                     },
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "hourly",
                     position: (439, 19),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Expression {
                     expression: String {
                      parts: [
                       Raw {
                        content: "daily",
                        position: (440, 8),
                       },
                      ],
                     },
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "daily",
                     position: (440, 18),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Expression {
                     expression: String {
                      parts: [
                       Raw {
                        content: "weekly",
                        position: (441, 8),
                       },
                      ],
                     },
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "weekly",
                     position: (441, 19),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Expression {
                     expression: String {
                      parts: [
                       Raw {
                        content: "yearly",
                        position: (442, 8),
                       },
                      ],
                     },
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "yearly",
                     position: (442, 19),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (436, 29),
               },
               Function {
                argument: Some(
                 "name",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: Function {
                 argument: Some(
                  "startAt",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "lib",
                    position: (444, 7),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nameValuePair",
                      position: (444, 11),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "hyperkitty-",
                      position: (444, 26),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "name",
                       position: (444, 39),
                      },
                     },
                    ],
                   },
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "lib",
                      position: (444, 47),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "mkIf",
                        position: (444, 51),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (444, 56),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "hyperkitty",
                         position: (444, 60),
                        },
                        Raw {
                         content: "enable",
                         position: (444, 71),
                        },
                       ],
                      },
                      default: None,
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "description",
                           position: (445, 9),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "Trigger ",
                           position: (445, 24),
                          },
                          Expression {
                           expression: Variable {
                            identifier: "name",
                            position: (445, 34),
                           },
                          },
                          Raw {
                           content: " Hyperkitty events",
                           position: (445, 39),
                          },
                         ],
                        },
                       ),
                       Inherit(
                        None,
                        [
                         Raw {
                          content: "startAt",
                          position: (446, 17),
                         },
                        ],
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "restartTriggers",
                           position: (447, 9),
                          },
                         ],
                        },
                        List {
                         elements: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "config",
                            position: (447, 29),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "environment",
                              position: (447, 36),
                             },
                             Raw {
                              content: "etc",
                              position: (447, 48),
                             },
                             Expression {
                              expression: String {
                               parts: [
                                Raw {
                                 content: "mailman3/settings.py",
                                 position: (447, 53),
                                },
                               ],
                              },
                             },
                             Raw {
                              content: "source",
                              position: (447, 75),
                             },
                            ],
                           },
                           default: None,
                          },
                         ],
                         position: (447, 27),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "serviceConfig",
                           position: (448, 9),
                          },
                         ],
                        },
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "ExecStart",
                              position: (449, 11),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Expression {
                              expression: Variable {
                               identifier: "pythonEnv",
                               position: (449, 26),
                              },
                             },
                             Raw {
                              content: "/bin/mailman-web runjobs ",
                              position: (449, 36),
                             },
                             Expression {
                              expression: Variable {
                               identifier: "name",
                               position: (449, 63),
                              },
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "User",
                              position: (450, 11),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (450, 18),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "webUser",
                               position: (450, 22),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "Group",
                              position: (451, 11),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "mailman",
                              position: (451, 20),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "WorkingDirectory",
                              position: (452, 11),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "/var/lib/mailman-web",
                              position: (452, 31),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (448, 25),
                        },
                       ),
                      ],
                      recursive: false,
                      position: (444, 78),
                     },
                    ],
                   },
                  ],
                 },
                 position: (443, 14),
                },
                position: (443, 8),
               },
              ],
             },
            ],
            position: (436, 7),
           },
          ),
         ],
         recursive: false,
         position: (181, 28),
        },
       ],
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "meta",
         position: (457, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "maintainers",
            position: (458, 5),
           },
          ],
         },
         With {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "lib",
            position: (458, 24),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "maintainers",
              position: (458, 28),
             },
            ],
           },
           default: None,
          },
          target: List {
           elements: [
            Variable {
             identifier: "lheckemann",
             position: (458, 43),
            },
            Variable {
             identifier: "qyliss",
             position: (458, 54),
            },
           ],
           position: (458, 41),
          },
          position: (458, 19),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "doc",
            position: (459, 5),
           },
          ],
         },
         Path {
          parts: [
           Raw {
            content: "./mailman.xml",
            position: (459, 11),
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (457, 10),
      },
     ),
    ],
    recursive: false,
    position: (62, 4),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}