---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "options",
    default: None,
   },
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: LetIn {
  bindings: [
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "cfg",
       position: (4, 3),
      },
     ],
    },
    PropertyAccess {
     expression: Variable {
      identifier: "config",
      position: (4, 9),
     },
     attribute_path: AttributePath {
      attributes: [
       Raw {
        content: "services",
        position: (4, 16),
       },
       Raw {
        content: "parsedmarc",
        position: (4, 25),
       },
      ],
     },
     default: None,
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "opt",
       position: (5, 3),
      },
     ],
    },
    PropertyAccess {
     expression: Variable {
      identifier: "options",
      position: (5, 9),
     },
     attribute_path: AttributePath {
      attributes: [
       Raw {
        content: "services",
        position: (5, 17),
       },
       Raw {
        content: "parsedmarc",
        position: (5, 26),
       },
      ],
     },
     default: None,
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "ini",
       position: (6, 3),
      },
     ],
    },
    FunctionApplication {
     function: PropertyAccess {
      expression: Variable {
       identifier: "pkgs",
       position: (6, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "formats",
         position: (6, 14),
        },
        Raw {
         content: "ini",
         position: (6, 22),
        },
       ],
      },
      default: None,
     },
     arguments: [
      Map {
       bindings: [],
       recursive: false,
       position: (6, 26),
      },
     ],
    },
   ),
  ],
  target: Map {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "options",
        position: (9, 3),
       },
       Raw {
        content: "services",
        position: (9, 11),
       },
       Raw {
        content: "parsedmarc",
        position: (9, 20),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "enable",
           position: (11, 5),
          },
         ],
        },
        FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "lib",
           position: (11, 14),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "mkEnableOption",
             position: (11, 18),
            },
           ],
          },
          default: None,
         },
         arguments: [
          String {
           parts: [
            Raw {
             content: "parsedmarc, a DMARC report monitoring service\n",
             position: (12, 1),
            },
           ],
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "provision",
           position: (15, 5),
          },
         ],
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "localMail",
              position: (16, 7),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "enable",
                 position: (17, 9),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (17, 18),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "mkOption",
                   position: (17, 22),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (18, 11),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "lib",
                     position: (18, 18),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "types",
                       position: (18, 22),
                      },
                      Raw {
                       content: "bool",
                       position: (18, 28),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (19, 11),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (19, 21),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (20, 11),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Whether Postfix and Dovecot should be set up to receive\nmail locally. parsedmarc will be configured to watch the\nlocal inbox as the automatically created user specified in\n<xref linkend=\"opt-services.parsedmarc.provision.localMail.recipientName\" />\n",
                      position: (21, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (17, 31),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "recipientName",
                 position: (28, 9),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (28, 25),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "mkOption",
                   position: (28, 29),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (29, 11),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "lib",
                     position: (29, 18),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "types",
                       position: (29, 22),
                      },
                      Raw {
                       content: "str",
                       position: (29, 28),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (30, 11),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "dmarc",
                      position: (30, 22),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (31, 11),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "The DMARC mail recipient name, i.e. the name part of the\nemail address which receives DMARC reports.\n\nA local user with this name will be set up and assigned a\nrandomized password on service start.\n",
                      position: (32, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (28, 38),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "hostname",
                 position: (40, 9),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (40, 20),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "mkOption",
                   position: (40, 24),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (41, 11),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "lib",
                     position: (41, 18),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "types",
                       position: (41, 22),
                      },
                      Raw {
                       content: "str",
                       position: (41, 28),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (42, 11),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (42, 21),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "networking",
                       position: (42, 28),
                      },
                      Raw {
                       content: "fqdn",
                       position: (42, 39),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "defaultText",
                      position: (43, 11),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "lib",
                      position: (43, 25),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "literalExpression",
                        position: (43, 29),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "config.networking.fqdn",
                        position: (43, 48),
                       },
                      ],
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "example",
                      position: (44, 11),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "monitoring.example.com",
                      position: (44, 22),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (45, 11),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "The hostname to use when configuring Postfix.\n\nShould correspond to the host's fully qualified domain\nname and the domain part of the email address which\nreceives DMARC reports. You also have to set up an MX record\npointing to this domain name.\n",
                      position: (46, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (40, 33),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (16, 19),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "geoIp",
              position: (56, 7),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "lib",
              position: (56, 15),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "mkOption",
                position: (56, 19),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (57, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "lib",
                  position: (57, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "types",
                    position: (57, 20),
                   },
                   Raw {
                    content: "bool",
                    position: (57, 26),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "default",
                   position: (58, 9),
                  },
                 ],
                },
                Variable {
                 identifier: "true",
                 position: (58, 19),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (59, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Whether to enable and configure the <link\nlinkend=\"opt-services.geoipupdate.enable\">geoipupdate</link>\nservice to automatically fetch GeoIP databases. Not crucial,\nbut recommended for full functionality.\n\nTo finish the setup, you need to manually set the <xref\nlinkend=\"opt-services.geoipupdate.settings.AccountID\" /> and\n<xref linkend=\"opt-services.geoipupdate.settings.LicenseKey\" />\noptions.\n",
                   position: (60, 1),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (56, 28),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "elasticsearch",
              position: (72, 7),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "lib",
              position: (72, 23),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "mkOption",
                position: (72, 27),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (73, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "lib",
                  position: (73, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "types",
                    position: (73, 20),
                   },
                   Raw {
                    content: "bool",
                    position: (73, 26),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "default",
                   position: (74, 9),
                  },
                 ],
                },
                Variable {
                 identifier: "true",
                 position: (74, 19),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (75, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Whether to set up and use a local instance of Elasticsearch.\n",
                   position: (76, 1),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (72, 36),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "grafana",
              position: (80, 7),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "datasource",
                 position: (81, 9),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (81, 22),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "mkOption",
                   position: (81, 26),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (82, 11),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "lib",
                     position: (82, 18),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "types",
                       position: (82, 22),
                      },
                      Raw {
                       content: "bool",
                       position: (82, 28),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (83, 11),
                     },
                    ],
                   },
                   BinaryOperation {
                    operator: LogicalAnd,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (83, 21),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "provision",
                         position: (83, 25),
                        },
                        Raw {
                         content: "elasticsearch",
                         position: (83, 35),
                        },
                       ],
                      },
                      default: None,
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (83, 52),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "services",
                         position: (83, 59),
                        },
                        Raw {
                         content: "grafana",
                         position: (83, 68),
                        },
                        Raw {
                         content: "enable",
                         position: (83, 76),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                    position: (83, 49),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "defaultText",
                      position: (84, 11),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "lib",
                      position: (84, 25),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "literalExpression",
                        position: (84, 29),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "config.",
                        position: (85, 1),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "opt",
                          position: (85, 22),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "provision",
                            position: (85, 26),
                           },
                           Raw {
                            content: "elasticsearch",
                            position: (85, 36),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: " && config.",
                        position: (85, 50),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "options",
                          position: (85, 63),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "services",
                            position: (85, 71),
                           },
                           Raw {
                            content: "grafana",
                            position: (85, 80),
                           },
                           Raw {
                            content: "enable",
                            position: (85, 88),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "\n",
                        position: (85, 95),
                       },
                      ],
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "apply",
                      position: (87, 11),
                     },
                    ],
                   },
                   Function {
                    argument: Some(
                     "x",
                    ),
                    arguments: FunctionArguments {
                     arguments: [],
                     ellipsis: false,
                    },
                    definition: BinaryOperation {
                     operator: LogicalAnd,
                     operands: [
                      Variable {
                       identifier: "x",
                       position: (87, 22),
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (87, 27),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "provision",
                          position: (87, 31),
                         },
                         Raw {
                          content: "elasticsearch",
                          position: (87, 41),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                     position: (87, 24),
                    },
                    position: (87, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (88, 11),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Whether the automatically provisioned Elasticsearch\ninstance should be added as a grafana datasource. Has no\neffect unless\n<xref linkend=\"opt-services.parsedmarc.provision.elasticsearch\" />\nis also enabled.\n",
                      position: (89, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (81, 35),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "dashboard",
                 position: (97, 9),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (97, 21),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "mkOption",
                   position: (97, 25),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (98, 11),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "lib",
                     position: (98, 18),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "types",
                       position: (98, 22),
                      },
                      Raw {
                       content: "bool",
                       position: (98, 28),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (99, 11),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (99, 21),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "services",
                       position: (99, 28),
                      },
                      Raw {
                       content: "grafana",
                       position: (99, 37),
                      },
                      Raw {
                       content: "enable",
                       position: (99, 45),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "defaultText",
                      position: (100, 11),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "lib",
                      position: (100, 25),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "literalExpression",
                        position: (100, 29),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "config.services.grafana.enable",
                        position: (100, 48),
                       },
                      ],
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (101, 11),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Whether the official parsedmarc grafana dashboard should\nbe provisioned to the local grafana instance.\n",
                      position: (102, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (97, 34),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (80, 17),
           },
          ),
         ],
         recursive: false,
         position: (15, 17),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "settings",
           position: (109, 5),
          },
         ],
        },
        FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "lib",
           position: (109, 16),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "mkOption",
             position: (109, 20),
            },
           ],
          },
          default: None,
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (110, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Configuration parameters to set in\n<filename>parsedmarc.ini</filename>. For a full list of\navailable parameters, see\n<link xlink:href=\"https://domainaware.github.io/parsedmarc/#configuration-file\" />.\n",
                position: (111, 1),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (117, 7),
               },
              ],
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "lib",
                position: (117, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "types",
                  position: (117, 18),
                 },
                 Raw {
                  content: "submodule",
                  position: (117, 24),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "freeformType",
                     position: (118, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "ini",
                    position: (118, 24),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (118, 28),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "options",
                     position: (120, 9),
                    },
                   ],
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "general",
                        position: (121, 11),
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "save_aggregate",
                           position: (122, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (122, 30),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (122, 34),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (123, 15),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "lib",
                               position: (123, 22),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "types",
                                 position: (123, 26),
                                },
                                Raw {
                                 content: "bool",
                                 position: (123, 32),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (124, 15),
                               },
                              ],
                             },
                             Variable {
                              identifier: "true",
                              position: (124, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (125, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Save aggregate report data to Elasticsearch and/or Splunk.\n",
                                position: (126, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (122, 43),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "save_forensic",
                           position: (130, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (130, 29),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (130, 33),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (131, 15),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "lib",
                               position: (131, 22),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "types",
                                 position: (131, 26),
                                },
                                Raw {
                                 content: "bool",
                                 position: (131, 32),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (132, 15),
                               },
                              ],
                             },
                             Variable {
                              identifier: "true",
                              position: (132, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (133, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Save forensic report data to Elasticsearch and/or Splunk.\n",
                                position: (134, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (130, 42),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (121, 21),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "imap",
                        position: (139, 11),
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "host",
                           position: (140, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (140, 20),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (140, 24),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (141, 15),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "lib",
                               position: (141, 22),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "types",
                                 position: (141, 26),
                                },
                                Raw {
                                 content: "str",
                                 position: (141, 32),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (142, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "localhost",
                                position: (142, 26),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (143, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "The IMAP server hostname or IP address.\n",
                                position: (144, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (140, 33),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "port",
                           position: (148, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (148, 20),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (148, 24),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (149, 15),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "lib",
                               position: (149, 22),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "types",
                                 position: (149, 26),
                                },
                                Raw {
                                 content: "port",
                                 position: (149, 32),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (150, 15),
                               },
                              ],
                             },
                             Int {
                              value: 993,
                              position: (150, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (151, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "The IMAP server port.\n",
                                position: (152, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (148, 33),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "ssl",
                           position: (156, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (156, 19),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (156, 23),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (157, 15),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "lib",
                               position: (157, 22),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "types",
                                 position: (157, 26),
                                },
                                Raw {
                                 content: "bool",
                                 position: (157, 32),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (158, 15),
                               },
                              ],
                             },
                             Variable {
                              identifier: "true",
                              position: (158, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (159, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Use an encrypted SSL/TLS connection.\n",
                                position: (160, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (156, 32),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "user",
                           position: (164, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (164, 20),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (164, 24),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (165, 15),
                               },
                              ],
                             },
                             With {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "lib",
                                position: (165, 27),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "types",
                                  position: (165, 31),
                                 },
                                ],
                               },
                               default: None,
                              },
                              target: FunctionApplication {
                               function: Variable {
                                identifier: "nullOr",
                                position: (165, 38),
                               },
                               arguments: [
                                Variable {
                                 identifier: "str",
                                 position: (165, 45),
                                },
                               ],
                              },
                              position: (165, 22),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (166, 15),
                               },
                              ],
                             },
                             Variable {
                              identifier: "null",
                              position: (166, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (167, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "The IMAP server username.\n",
                                position: (168, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (164, 33),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "password",
                           position: (172, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (172, 24),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (172, 28),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (173, 15),
                               },
                              ],
                             },
                             With {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "lib",
                                position: (173, 27),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "types",
                                  position: (173, 31),
                                 },
                                ],
                               },
                               default: None,
                              },
                              target: FunctionApplication {
                               function: Variable {
                                identifier: "nullOr",
                                position: (173, 38),
                               },
                               arguments: [
                                Variable {
                                 identifier: "path",
                                 position: (173, 45),
                                },
                               ],
                              },
                              position: (173, 22),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (174, 15),
                               },
                              ],
                             },
                             Variable {
                              identifier: "null",
                              position: (174, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (175, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "The path to a file containing the IMAP server password.\n",
                                position: (176, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (172, 37),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "watch",
                           position: (180, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (180, 21),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (180, 25),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (181, 15),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "lib",
                               position: (181, 22),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "types",
                                 position: (181, 26),
                                },
                                Raw {
                                 content: "bool",
                                 position: (181, 32),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (182, 15),
                               },
                              ],
                             },
                             Variable {
                              identifier: "true",
                              position: (182, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (183, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Use the IMAP IDLE command to process messages as they arrive.\n",
                                position: (184, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (180, 34),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "delete",
                           position: (188, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (188, 22),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (188, 26),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (189, 15),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "lib",
                               position: (189, 22),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "types",
                                 position: (189, 26),
                                },
                                Raw {
                                 content: "bool",
                                 position: (189, 32),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (190, 15),
                               },
                              ],
                             },
                             Variable {
                              identifier: "false",
                              position: (190, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (191, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Delete messages after processing them, instead of archiving them.\n",
                                position: (192, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (188, 35),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (139, 18),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "smtp",
                        position: (197, 11),
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "host",
                           position: (198, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (198, 20),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (198, 24),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (199, 15),
                               },
                              ],
                             },
                             With {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "lib",
                                position: (199, 27),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "types",
                                  position: (199, 31),
                                 },
                                ],
                               },
                               default: None,
                              },
                              target: FunctionApplication {
                               function: Variable {
                                identifier: "nullOr",
                                position: (199, 38),
                               },
                               arguments: [
                                Variable {
                                 identifier: "str",
                                 position: (199, 45),
                                },
                               ],
                              },
                              position: (199, 22),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (200, 15),
                               },
                              ],
                             },
                             Variable {
                              identifier: "null",
                              position: (200, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (201, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "The SMTP server hostname or IP address.\n",
                                position: (202, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (198, 33),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "port",
                           position: (206, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (206, 20),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (206, 24),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (207, 15),
                               },
                              ],
                             },
                             With {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "lib",
                                position: (207, 27),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "types",
                                  position: (207, 31),
                                 },
                                ],
                               },
                               default: None,
                              },
                              target: FunctionApplication {
                               function: Variable {
                                identifier: "nullOr",
                                position: (207, 38),
                               },
                               arguments: [
                                Variable {
                                 identifier: "port",
                                 position: (207, 45),
                                },
                               ],
                              },
                              position: (207, 22),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (208, 15),
                               },
                              ],
                             },
                             Variable {
                              identifier: "null",
                              position: (208, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (209, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "The SMTP server port.\n",
                                position: (210, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (206, 33),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "ssl",
                           position: (214, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (214, 19),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (214, 23),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (215, 15),
                               },
                              ],
                             },
                             With {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "lib",
                                position: (215, 27),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "types",
                                  position: (215, 31),
                                 },
                                ],
                               },
                               default: None,
                              },
                              target: FunctionApplication {
                               function: Variable {
                                identifier: "nullOr",
                                position: (215, 38),
                               },
                               arguments: [
                                Variable {
                                 identifier: "bool",
                                 position: (215, 45),
                                },
                               ],
                              },
                              position: (215, 22),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (216, 15),
                               },
                              ],
                             },
                             Variable {
                              identifier: "null",
                              position: (216, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (217, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Use an encrypted SSL/TLS connection.\n",
                                position: (218, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (214, 32),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "user",
                           position: (222, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (222, 20),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (222, 24),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (223, 15),
                               },
                              ],
                             },
                             With {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "lib",
                                position: (223, 27),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "types",
                                  position: (223, 31),
                                 },
                                ],
                               },
                               default: None,
                              },
                              target: FunctionApplication {
                               function: Variable {
                                identifier: "nullOr",
                                position: (223, 38),
                               },
                               arguments: [
                                Variable {
                                 identifier: "str",
                                 position: (223, 45),
                                },
                               ],
                              },
                              position: (223, 22),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (224, 15),
                               },
                              ],
                             },
                             Variable {
                              identifier: "null",
                              position: (224, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (225, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "The SMTP server username.\n",
                                position: (226, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (222, 33),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "password",
                           position: (230, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (230, 24),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (230, 28),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (231, 15),
                               },
                              ],
                             },
                             With {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "lib",
                                position: (231, 27),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "types",
                                  position: (231, 31),
                                 },
                                ],
                               },
                               default: None,
                              },
                              target: FunctionApplication {
                               function: Variable {
                                identifier: "nullOr",
                                position: (231, 38),
                               },
                               arguments: [
                                Variable {
                                 identifier: "path",
                                 position: (231, 45),
                                },
                               ],
                              },
                              position: (231, 22),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (232, 15),
                               },
                              ],
                             },
                             Variable {
                              identifier: "null",
                              position: (232, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (233, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "The path to a file containing the SMTP server password.\n",
                                position: (234, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (230, 37),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "from",
                           position: (238, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (238, 20),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (238, 24),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (239, 15),
                               },
                              ],
                             },
                             With {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "lib",
                                position: (239, 27),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "types",
                                  position: (239, 31),
                                 },
                                ],
                               },
                               default: None,
                              },
                              target: FunctionApplication {
                               function: Variable {
                                identifier: "nullOr",
                                position: (239, 38),
                               },
                               arguments: [
                                Variable {
                                 identifier: "str",
                                 position: (239, 45),
                                },
                               ],
                              },
                              position: (239, 22),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (240, 15),
                               },
                              ],
                             },
                             Variable {
                              identifier: "null",
                              position: (240, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (241, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "The <literal>From</literal> address to use for the\noutgoing mail.\n",
                                position: (242, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (238, 33),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "to",
                           position: (247, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (247, 18),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (247, 22),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (248, 15),
                               },
                              ],
                             },
                             With {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "lib",
                                position: (248, 27),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "types",
                                  position: (248, 31),
                                 },
                                ],
                               },
                               default: None,
                              },
                              target: FunctionApplication {
                               function: Variable {
                                identifier: "nullOr",
                                position: (248, 38),
                               },
                               arguments: [
                                FunctionApplication {
                                 function: Variable {
                                  identifier: "listOf",
                                  position: (248, 46),
                                 },
                                 arguments: [
                                  Variable {
                                   identifier: "str",
                                   position: (248, 53),
                                  },
                                 ],
                                },
                               ],
                              },
                              position: (248, 22),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (249, 15),
                               },
                              ],
                             },
                             Variable {
                              identifier: "null",
                              position: (249, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (250, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "The addresses to send outgoing mail to.\n",
                                position: (251, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (247, 31),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (197, 18),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "elasticsearch",
                        position: (256, 11),
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "hosts",
                           position: (257, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (257, 21),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (257, 25),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (258, 15),
                               },
                              ],
                             },
                             List {
                              elements: [],
                              position: (258, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (259, 15),
                               },
                              ],
                             },
                             With {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "lib",
                                position: (259, 27),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "types",
                                  position: (259, 31),
                                 },
                                ],
                               },
                               default: None,
                              },
                              target: FunctionApplication {
                               function: Variable {
                                identifier: "listOf",
                                position: (259, 38),
                               },
                               arguments: [
                                Variable {
                                 identifier: "str",
                                 position: (259, 45),
                                },
                               ],
                              },
                              position: (259, 22),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "apply",
                                position: (260, 15),
                               },
                              ],
                             },
                             Function {
                              argument: Some(
                               "x",
                              ),
                              arguments: FunctionArguments {
                               arguments: [],
                               ellipsis: false,
                              },
                              definition: IfThenElse {
                               predicate: BinaryOperation {
                                operator: EqualTo,
                                operands: [
                                 Variable {
                                  identifier: "x",
                                  position: (260, 29),
                                 },
                                 List {
                                  elements: [],
                                  position: (260, 34),
                                 },
                                ],
                                position: (260, 31),
                               },
                               then: Variable {
                                identifier: "null",
                                position: (260, 42),
                               },
                               else_: FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "lib",
                                  position: (260, 52),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "concatStringsSep",
                                    position: (260, 56),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 String {
                                  parts: [
                                   Raw {
                                    content: ",",
                                    position: (260, 74),
                                   },
                                  ],
                                 },
                                 Variable {
                                  identifier: "x",
                                  position: (260, 77),
                                 },
                                ],
                               },
                               position: (260, 26),
                              },
                              position: (260, 23),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (261, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "A list of Elasticsearch hosts to push parsed reports\nto.\n",
                                position: (262, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (257, 34),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "user",
                           position: (267, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (267, 20),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (267, 24),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (268, 15),
                               },
                              ],
                             },
                             With {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "lib",
                                position: (268, 27),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "types",
                                  position: (268, 31),
                                 },
                                ],
                               },
                               default: None,
                              },
                              target: FunctionApplication {
                               function: Variable {
                                identifier: "nullOr",
                                position: (268, 38),
                               },
                               arguments: [
                                Variable {
                                 identifier: "str",
                                 position: (268, 45),
                                },
                               ],
                              },
                              position: (268, 22),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (269, 15),
                               },
                              ],
                             },
                             Variable {
                              identifier: "null",
                              position: (269, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (270, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Username to use when connecting to Elasticsearch, if\nrequired.\n",
                                position: (271, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (267, 33),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "password",
                           position: (276, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (276, 24),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (276, 28),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (277, 15),
                               },
                              ],
                             },
                             With {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "lib",
                                position: (277, 27),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "types",
                                  position: (277, 31),
                                 },
                                ],
                               },
                               default: None,
                              },
                              target: FunctionApplication {
                               function: Variable {
                                identifier: "nullOr",
                                position: (277, 38),
                               },
                               arguments: [
                                Variable {
                                 identifier: "path",
                                 position: (277, 45),
                                },
                               ],
                              },
                              position: (277, 22),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (278, 15),
                               },
                              ],
                             },
                             Variable {
                              identifier: "null",
                              position: (278, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (279, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "The path to a file containing the password to use when\nconnecting to Elasticsearch, if required.\n",
                                position: (280, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (276, 37),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "ssl",
                           position: (285, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (285, 19),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (285, 23),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (286, 15),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "lib",
                               position: (286, 22),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "types",
                                 position: (286, 26),
                                },
                                Raw {
                                 content: "bool",
                                 position: (286, 32),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (287, 15),
                               },
                              ],
                             },
                             Variable {
                              identifier: "false",
                              position: (287, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (288, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Whether to use an encrypted SSL/TLS connection.\n",
                                position: (289, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (285, 32),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "cert_path",
                           position: (293, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (293, 25),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (293, 29),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (294, 15),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "lib",
                               position: (294, 22),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "types",
                                 position: (294, 26),
                                },
                                Raw {
                                 content: "path",
                                 position: (294, 32),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (295, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "/etc/ssl/certs/ca-certificates.crt",
                                position: (295, 26),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (296, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "The path to a TLS certificate bundle used to verify\nthe server's certificate.\n",
                                position: (297, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (293, 38),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (256, 27),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "kafka",
                        position: (303, 11),
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "hosts",
                           position: (304, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (304, 21),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (304, 25),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (305, 15),
                               },
                              ],
                             },
                             List {
                              elements: [],
                              position: (305, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (306, 15),
                               },
                              ],
                             },
                             With {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "lib",
                                position: (306, 27),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "types",
                                  position: (306, 31),
                                 },
                                ],
                               },
                               default: None,
                              },
                              target: FunctionApplication {
                               function: Variable {
                                identifier: "listOf",
                                position: (306, 38),
                               },
                               arguments: [
                                Variable {
                                 identifier: "str",
                                 position: (306, 45),
                                },
                               ],
                              },
                              position: (306, 22),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "apply",
                                position: (307, 15),
                               },
                              ],
                             },
                             Function {
                              argument: Some(
                               "x",
                              ),
                              arguments: FunctionArguments {
                               arguments: [],
                               ellipsis: false,
                              },
                              definition: IfThenElse {
                               predicate: BinaryOperation {
                                operator: EqualTo,
                                operands: [
                                 Variable {
                                  identifier: "x",
                                  position: (307, 29),
                                 },
                                 List {
                                  elements: [],
                                  position: (307, 34),
                                 },
                                ],
                                position: (307, 31),
                               },
                               then: Variable {
                                identifier: "null",
                                position: (307, 42),
                               },
                               else_: FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "lib",
                                  position: (307, 52),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "concatStringsSep",
                                    position: (307, 56),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 String {
                                  parts: [
                                   Raw {
                                    content: ",",
                                    position: (307, 74),
                                   },
                                  ],
                                 },
                                 Variable {
                                  identifier: "x",
                                  position: (307, 77),
                                 },
                                ],
                               },
                               position: (307, 26),
                              },
                              position: (307, 23),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (308, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "A list of Apache Kafka hosts to publish parsed reports\nto.\n",
                                position: (309, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (304, 34),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "user",
                           position: (314, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (314, 20),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (314, 24),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (315, 15),
                               },
                              ],
                             },
                             With {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "lib",
                                position: (315, 27),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "types",
                                  position: (315, 31),
                                 },
                                ],
                               },
                               default: None,
                              },
                              target: FunctionApplication {
                               function: Variable {
                                identifier: "nullOr",
                                position: (315, 38),
                               },
                               arguments: [
                                Variable {
                                 identifier: "str",
                                 position: (315, 45),
                                },
                               ],
                              },
                              position: (315, 22),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (316, 15),
                               },
                              ],
                             },
                             Variable {
                              identifier: "null",
                              position: (316, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (317, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Username to use when connecting to Kafka, if\nrequired.\n",
                                position: (318, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (314, 33),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "password",
                           position: (323, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (323, 24),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (323, 28),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (324, 15),
                               },
                              ],
                             },
                             With {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "lib",
                                position: (324, 27),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "types",
                                  position: (324, 31),
                                 },
                                ],
                               },
                               default: None,
                              },
                              target: FunctionApplication {
                               function: Variable {
                                identifier: "nullOr",
                                position: (324, 38),
                               },
                               arguments: [
                                Variable {
                                 identifier: "path",
                                 position: (324, 45),
                                },
                               ],
                              },
                              position: (324, 22),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (325, 15),
                               },
                              ],
                             },
                             Variable {
                              identifier: "null",
                              position: (325, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (326, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "The path to a file containing the password to use when\nconnecting to Kafka, if required.\n",
                                position: (327, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (323, 37),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "ssl",
                           position: (332, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (332, 19),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (332, 23),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (333, 15),
                               },
                              ],
                             },
                             With {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "lib",
                                position: (333, 27),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "types",
                                  position: (333, 31),
                                 },
                                ],
                               },
                               default: None,
                              },
                              target: FunctionApplication {
                               function: Variable {
                                identifier: "nullOr",
                                position: (333, 38),
                               },
                               arguments: [
                                Variable {
                                 identifier: "bool",
                                 position: (333, 45),
                                },
                               ],
                              },
                              position: (333, 22),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (334, 15),
                               },
                              ],
                             },
                             Variable {
                              identifier: "null",
                              position: (334, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (335, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Whether to use an encrypted SSL/TLS connection.\n",
                                position: (336, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (332, 32),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "aggregate_topic",
                           position: (340, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (340, 31),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (340, 35),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (341, 15),
                               },
                              ],
                             },
                             With {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "lib",
                                position: (341, 27),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "types",
                                  position: (341, 31),
                                 },
                                ],
                               },
                               default: None,
                              },
                              target: FunctionApplication {
                               function: Variable {
                                identifier: "nullOr",
                                position: (341, 38),
                               },
                               arguments: [
                                Variable {
                                 identifier: "str",
                                 position: (341, 45),
                                },
                               ],
                              },
                              position: (341, 22),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (342, 15),
                               },
                              ],
                             },
                             Variable {
                              identifier: "null",
                              position: (342, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "example",
                                position: (343, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "aggregate",
                                position: (343, 26),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (344, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "The Kafka topic to publish aggregate reports on.\n",
                                position: (345, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (340, 44),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "forensic_topic",
                           position: (349, 13),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (349, 30),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "mkOption",
                             position: (349, 34),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (350, 15),
                               },
                              ],
                             },
                             With {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "lib",
                                position: (350, 27),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "types",
                                  position: (350, 31),
                                 },
                                ],
                               },
                               default: None,
                              },
                              target: FunctionApplication {
                               function: Variable {
                                identifier: "nullOr",
                                position: (350, 38),
                               },
                               arguments: [
                                Variable {
                                 identifier: "str",
                                 position: (350, 45),
                                },
                               ],
                              },
                              position: (350, 22),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (351, 15),
                               },
                              ],
                             },
                             Variable {
                              identifier: "null",
                              position: (351, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "example",
                                position: (352, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "forensic",
                                position: (352, 26),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (353, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "The Kafka topic to publish forensic reports on.\n",
                                position: (354, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (349, 43),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (303, 19),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (120, 19),
                  },
                 ),
                ],
                recursive: false,
                position: (117, 34),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (109, 29),
          },
         ],
        },
       ),
      ],
      recursive: false,
      position: (9, 33),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "config",
        position: (366, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "lib",
        position: (366, 12),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "mkIf",
          position: (366, 16),
         },
        ],
       },
       default: None,
      },
      arguments: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (366, 21),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "enable",
           position: (366, 25),
          },
         ],
        },
        default: None,
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "services",
             position: (368, 5),
            },
            Raw {
             content: "elasticsearch",
             position: (368, 14),
            },
            Raw {
             content: "enable",
             position: (368, 28),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (368, 37),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "mkDefault",
               position: (368, 41),
              },
             ],
            },
            default: None,
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (368, 51),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "provision",
                position: (368, 55),
               },
               Raw {
                content: "elasticsearch",
                position: (368, 65),
               },
              ],
             },
             default: None,
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "services",
             position: (370, 5),
            },
            Raw {
             content: "geoipupdate",
             position: (370, 14),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (370, 28),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "mkIf",
               position: (370, 32),
              },
             ],
            },
            default: None,
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (370, 37),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "provision",
                position: (370, 41),
               },
               Raw {
                content: "geoIp",
                position: (370, 51),
               },
              ],
             },
             default: None,
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "enable",
                  position: (371, 7),
                 },
                ],
               },
               Variable {
                identifier: "true",
                position: (371, 16),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "settings",
                  position: (372, 7),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "EditionIDs",
                     position: (373, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "GeoLite2-ASN",
                       position: (374, 12),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "GeoLite2-City",
                       position: (375, 12),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "GeoLite2-Country",
                       position: (376, 12),
                      },
                     ],
                    },
                   ],
                   position: (373, 22),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "DatabaseDirectory",
                     position: (378, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "/var/lib/GeoIP",
                     position: (378, 30),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (372, 18),
               },
              ),
             ],
             recursive: false,
             position: (370, 57),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "services",
             position: (382, 5),
            },
            Raw {
             content: "dovecot2",
             position: (382, 14),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (382, 25),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "mkIf",
               position: (382, 29),
              },
             ],
            },
            default: None,
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (382, 34),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "provision",
                position: (382, 38),
               },
               Raw {
                content: "localMail",
                position: (382, 48),
               },
               Raw {
                content: "enable",
                position: (382, 58),
               },
              ],
             },
             default: None,
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "enable",
                  position: (383, 7),
                 },
                ],
               },
               Variable {
                identifier: "true",
                position: (383, 16),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "protocols",
                  position: (384, 7),
                 },
                ],
               },
               List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "imap",
                    position: (384, 22),
                   },
                  ],
                 },
                ],
                position: (384, 19),
               },
              ),
             ],
             recursive: false,
             position: (382, 65),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "services",
             position: (387, 5),
            },
            Raw {
             content: "postfix",
             position: (387, 14),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (387, 24),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "mkIf",
               position: (387, 28),
              },
             ],
            },
            default: None,
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (387, 33),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "provision",
                position: (387, 37),
               },
               Raw {
                content: "localMail",
                position: (387, 47),
               },
               Raw {
                content: "enable",
                position: (387, 57),
               },
              ],
             },
             default: None,
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "enable",
                  position: (388, 7),
                 },
                ],
               },
               Variable {
                identifier: "true",
                position: (388, 16),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "origin",
                  position: (389, 7),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (389, 16),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "provision",
                   position: (389, 20),
                  },
                  Raw {
                   content: "localMail",
                   position: (389, 30),
                  },
                  Raw {
                   content: "hostname",
                   position: (389, 40),
                  },
                 ],
                },
                default: None,
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "config",
                  position: (390, 7),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "myhostname",
                     position: (391, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (391, 22),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "provision",
                      position: (391, 26),
                     },
                     Raw {
                      content: "localMail",
                      position: (391, 36),
                     },
                     Raw {
                      content: "hostname",
                      position: (391, 46),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "mydestination",
                     position: (392, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (392, 25),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "provision",
                      position: (392, 29),
                     },
                     Raw {
                      content: "localMail",
                      position: (392, 39),
                     },
                     Raw {
                      content: "hostname",
                      position: (392, 49),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                ],
                recursive: false,
                position: (390, 16),
               },
              ),
             ],
             recursive: false,
             position: (387, 64),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "services",
             position: (396, 5),
            },
            Raw {
             content: "grafana",
             position: (396, 14),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "declarativePlugins",
                position: (397, 7),
               },
              ],
             },
             With {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "pkgs",
                position: (397, 33),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "grafanaPlugins",
                  position: (397, 38),
                 },
                ],
               },
               default: None,
              },
              target: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (398, 9),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "mkIf",
                   position: (398, 13),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (398, 18),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "provision",
                    position: (398, 22),
                   },
                   Raw {
                    content: "grafana",
                    position: (398, 32),
                   },
                   Raw {
                    content: "dashboard",
                    position: (398, 40),
                   },
                  ],
                 },
                 default: None,
                },
                List {
                 elements: [
                  Variable {
                   identifier: "grafana-worldmap-panel",
                   position: (399, 11),
                  },
                  Variable {
                   identifier: "grafana-piechart-panel",
                   position: (400, 11),
                  },
                 ],
                 position: (398, 50),
                },
               ],
              },
              position: (397, 28),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "provision",
                position: (403, 7),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "enable",
                   position: (404, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: LogicalOr,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (404, 18),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "provision",
                      position: (404, 22),
                     },
                     Raw {
                      content: "grafana",
                      position: (404, 32),
                     },
                     Raw {
                      content: "datasource",
                      position: (404, 40),
                     },
                    ],
                   },
                   default: None,
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (404, 54),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "provision",
                      position: (404, 58),
                     },
                     Raw {
                      content: "grafana",
                      position: (404, 68),
                     },
                     Raw {
                      content: "dashboard",
                      position: (404, 76),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (404, 51),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "datasources",
                   position: (405, 9),
                  },
                 ],
                },
                LetIn {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "pkgVer",
                      position: (407, 13),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "lib",
                      position: (407, 22),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "getVersion",
                        position: (407, 26),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (407, 37),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "services",
                         position: (407, 44),
                        },
                        Raw {
                         content: "elasticsearch",
                         position: (407, 53),
                        },
                        Raw {
                         content: "package",
                         position: (407, 67),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "esVersion",
                      position: (408, 13),
                     },
                    ],
                   },
                   IfThenElse {
                    predicate: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "lib",
                       position: (409, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "versionOlder",
                         position: (409, 22),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      Variable {
                       identifier: "pkgVer",
                       position: (409, 35),
                      },
                      String {
                       parts: [
                        Raw {
                         content: "7",
                         position: (409, 43),
                        },
                       ],
                      },
                     ],
                    },
                    then: String {
                     parts: [
                      Raw {
                       content: "60",
                       position: (410, 18),
                      },
                     ],
                    },
                    else_: IfThenElse {
                     predicate: FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "lib",
                        position: (411, 23),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "versionOlder",
                          position: (411, 27),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       Variable {
                        identifier: "pkgVer",
                        position: (411, 40),
                       },
                       String {
                        parts: [
                         Raw {
                          content: "8",
                          position: (411, 48),
                         },
                        ],
                       },
                      ],
                     },
                     then: String {
                      parts: [
                       Raw {
                        content: "70",
                        position: (412, 18),
                       },
                      ],
                     },
                     else_: FunctionApplication {
                      function: Variable {
                       identifier: "throw",
                       position: (414, 17),
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "When provisioning parsedmarc grafana datasources: unknown Elasticsearch version.",
                          position: (414, 24),
                         },
                        ],
                       },
                      ],
                     },
                     position: (411, 20),
                    },
                    position: (409, 15),
                   },
                  ),
                 ],
                 target: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "lib",
                    position: (416, 13),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "mkIf",
                      position: (416, 17),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (416, 22),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "provision",
                       position: (416, 26),
                      },
                      Raw {
                       content: "grafana",
                       position: (416, 36),
                      },
                      Raw {
                       content: "datasource",
                       position: (416, 44),
                      },
                     ],
                    },
                    default: None,
                   },
                   List {
                    elements: [
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "name",
                           position: (418, 17),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "dmarc-ag",
                           position: (418, 25),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "type",
                           position: (419, 17),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "elasticsearch",
                           position: (419, 25),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "access",
                           position: (420, 17),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "proxy",
                           position: (420, 27),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "url",
                           position: (421, 17),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "localhost:9200",
                           position: (421, 24),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "jsonData",
                           position: (422, 17),
                          },
                         ],
                        },
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "timeField",
                              position: (423, 19),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "date_range",
                              position: (423, 32),
                             },
                            ],
                           },
                          ),
                          Inherit(
                           None,
                           [
                            Raw {
                             content: "esVersion",
                             position: (424, 27),
                            },
                           ],
                          ),
                         ],
                         recursive: false,
                         position: (422, 28),
                        },
                       ),
                      ],
                      recursive: false,
                      position: (417, 15),
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "name",
                           position: (428, 17),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "dmarc-fo",
                           position: (428, 25),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "type",
                           position: (429, 17),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "elasticsearch",
                           position: (429, 25),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "access",
                           position: (430, 17),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "proxy",
                           position: (430, 27),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "url",
                           position: (431, 17),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "localhost:9200",
                           position: (431, 24),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "jsonData",
                           position: (432, 17),
                          },
                         ],
                        },
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "timeField",
                              position: (433, 19),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "date_range",
                              position: (433, 32),
                             },
                            ],
                           },
                          ),
                          Inherit(
                           None,
                           [
                            Raw {
                             content: "esVersion",
                             position: (434, 27),
                            },
                           ],
                          ),
                         ],
                         recursive: false,
                         position: (432, 28),
                        },
                       ),
                      ],
                      recursive: false,
                      position: (427, 15),
                     },
                    ],
                    position: (416, 55),
                   },
                  ],
                 },
                 position: (406, 11),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "dashboards",
                   position: (438, 9),
                  },
                 ],
                },
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "lib",
                   position: (438, 22),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "mkIf",
                     position: (438, 26),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (438, 31),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "provision",
                      position: (438, 35),
                     },
                     Raw {
                      content: "grafana",
                      position: (438, 45),
                     },
                     Raw {
                      content: "dashboard",
                      position: (438, 53),
                     },
                    ],
                   },
                   default: None,
                  },
                  List {
                   elements: [
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "name",
                          position: (439, 11),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "parsedmarc",
                          position: (439, 19),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "options",
                          position: (440, 11),
                         },
                         Raw {
                          content: "path",
                          position: (440, 19),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "pkgs",
                            position: (440, 29),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "python3Packages",
                              position: (440, 34),
                             },
                             Raw {
                              content: "parsedmarc",
                              position: (440, 50),
                             },
                             Raw {
                              content: "dashboard",
                              position: (440, 61),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (438, 64),
                    },
                   ],
                   position: (438, 63),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (403, 19),
             },
            ),
           ],
           recursive: false,
           position: (396, 24),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "services",
             position: (445, 5),
            },
            Raw {
             content: "parsedmarc",
             position: (445, 14),
            },
            Raw {
             content: "settings",
             position: (445, 25),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (445, 36),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "mkMerge",
               position: (445, 40),
              },
             ],
            },
            default: None,
           },
           arguments: [
            List {
             elements: [
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (446, 8),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "mkIf",
                   position: (446, 12),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (446, 17),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "provision",
                    position: (446, 21),
                   },
                   Raw {
                    content: "elasticsearch",
                    position: (446, 31),
                   },
                  ],
                 },
                 default: None,
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "elasticsearch",
                      position: (447, 9),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "hosts",
                         position: (448, 11),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "localhost:9200",
                           position: (448, 22),
                          },
                         ],
                        },
                       ],
                       position: (448, 19),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "ssl",
                         position: (449, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (449, 17),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (447, 25),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (446, 45),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (452, 8),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "mkIf",
                   position: (452, 12),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (452, 17),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "provision",
                    position: (452, 21),
                   },
                   Raw {
                    content: "localMail",
                    position: (452, 31),
                   },
                   Raw {
                    content: "enable",
                    position: (452, 41),
                   },
                  ],
                 },
                 default: None,
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "imap",
                      position: (453, 9),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "host",
                         position: (454, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "localhost",
                         position: (454, 19),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "port",
                         position: (455, 11),
                        },
                       ],
                      },
                      Int {
                       value: 143,
                       position: (455, 18),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "ssl",
                         position: (456, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (456, 17),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "user",
                         position: (457, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (457, 18),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "provision",
                          position: (457, 22),
                         },
                         Raw {
                          content: "localMail",
                          position: (457, 32),
                         },
                         Raw {
                          content: "recipientName",
                          position: (457, 42),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "password",
                         position: (458, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Expression {
                         expression: FunctionApplication {
                          function: PropertyAccess {
                           expression: Variable {
                            identifier: "pkgs",
                            position: (458, 25),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "writeText",
                              position: (458, 30),
                             },
                            ],
                           },
                           default: None,
                          },
                          arguments: [
                           String {
                            parts: [
                             Raw {
                              content: "imap-password",
                              position: (458, 41),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "@imap-password@",
                              position: (458, 57),
                             },
                            ],
                           },
                          ],
                         },
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "watch",
                         position: (459, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "true",
                       position: (459, 19),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (453, 16),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (452, 48),
                },
               ],
              },
             ],
             position: (445, 48),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "systemd",
             position: (464, 5),
            },
            Raw {
             content: "services",
             position: (464, 13),
            },
            Raw {
             content: "parsedmarc",
             position: (464, 22),
            },
           ],
          },
          LetIn {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "filteredConfig",
                position: (470, 9),
               },
              ],
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "lib",
                position: (470, 26),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "converge",
                  position: (470, 30),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "lib",
                  position: (470, 40),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "filterAttrsRecursive",
                    position: (470, 44),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Function {
                  argument: Some(
                   "_",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: Function {
                   argument: Some(
                    "v",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: UnaryOperation {
                    operator: Not,
                    operand: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "builtins",
                       position: (470, 74),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "elem",
                         position: (470, 83),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      Variable {
                       identifier: "v",
                       position: (470, 88),
                      },
                      List {
                       elements: [
                        Variable {
                         identifier: "null",
                         position: (470, 92),
                        },
                        List {
                         elements: [],
                         position: (470, 97),
                        },
                        Map {
                         bindings: [],
                         recursive: false,
                         position: (470, 100),
                        },
                       ],
                       position: (470, 90),
                      },
                     ],
                    },
                    position: (470, 72),
                   },
                   position: (470, 69),
                  },
                  position: (470, 66),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (470, 107),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "settings",
                   position: (470, 111),
                  },
                 ],
                },
                default: None,
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "parsedmarcConfig",
                position: (471, 9),
               },
              ],
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "ini",
                position: (471, 28),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "generate",
                  position: (471, 32),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "parsedmarc.ini",
                  position: (471, 42),
                 },
                ],
               },
               Variable {
                identifier: "filteredConfig",
                position: (471, 58),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "mkSecretReplacement",
                position: (472, 9),
               },
              ],
             },
             Function {
              argument: Some(
               "file",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (473, 11),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "optionalString",
                   position: (473, 15),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                BinaryOperation {
                 operator: NotEqualTo,
                 operands: [
                  Variable {
                   identifier: "file",
                   position: (473, 31),
                  },
                  Variable {
                   identifier: "null",
                   position: (473, 39),
                  },
                 ],
                 position: (473, 36),
                },
                String {
                 parts: [
                  Raw {
                   content: "replace-secret ",
                   position: (474, 1),
                  },
                  Raw {
                   content: "'",
                   position: (474, 28),
                  },
                  Expression {
                   expression: Variable {
                    identifier: "file",
                    position: (474, 31),
                   },
                  },
                  Raw {
                   content: "' ",
                   position: (474, 36),
                  },
                  Raw {
                   content: "'",
                   position: (474, 38),
                  },
                  Expression {
                   expression: Variable {
                    identifier: "file",
                    position: (474, 41),
                   },
                  },
                  Raw {
                   content: "' /run/parsedmarc/parsedmarc.ini\n",
                   position: (474, 46),
                  },
                 ],
                },
               ],
              },
              position: (472, 31),
             },
            ),
           ],
           target: Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wantedBy",
                 position: (478, 11),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "multi-user.target",
                   position: (478, 25),
                  },
                 ],
                },
               ],
               position: (478, 22),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "after",
                 position: (479, 11),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "postfix.service",
                   position: (479, 22),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "dovecot2.service",
                   position: (479, 40),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "elasticsearch.service",
                   position: (479, 59),
                  },
                 ],
                },
               ],
               position: (479, 19),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (480, 11),
                },
               ],
              },
              With {
               expression: Variable {
                identifier: "pkgs",
                position: (480, 23),
               },
               target: List {
                elements: [
                 Variable {
                  identifier: "replace-secret",
                  position: (480, 31),
                 },
                 Variable {
                  identifier: "openssl",
                  position: (480, 46),
                 },
                 Variable {
                  identifier: "shadow",
                  position: (480, 54),
                 },
                ],
                position: (480, 29),
               },
               position: (480, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (481, 11),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStartPre",
                    position: (482, 13),
                   },
                  ],
                 },
                 LetIn {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "startPreFullPrivileges",
                       position: (483, 15),
                      },
                     ],
                    },
                    BinaryOperation {
                     operator: Addition,
                     operands: [
                      String {
                       parts: [
                        Raw {
                         content: "set -o errexit -o pipefail -o nounset -o errtrace\nshopt -s inherit_errexit\n\numask u=rwx,g=,o=\ncp ",
                         position: (484, 1),
                        },
                        Expression {
                         expression: Variable {
                          identifier: "parsedmarcConfig",
                          position: (488, 22),
                         },
                        },
                        Raw {
                         content: " /run/parsedmarc/parsedmarc.ini\nchown parsedmarc:parsedmarc /run/parsedmarc/parsedmarc.ini\n",
                         position: (488, 39),
                        },
                        Expression {
                         expression: FunctionApplication {
                          function: Variable {
                           identifier: "mkSecretReplacement",
                           position: (490, 19),
                          },
                          arguments: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (490, 39),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "settings",
                               position: (490, 43),
                              },
                              Raw {
                               content: "smtp",
                               position: (490, 52),
                              },
                              Raw {
                               content: "password",
                               position: (490, 57),
                              },
                             ],
                            },
                            default: None,
                           },
                          ],
                         },
                        },
                        Raw {
                         content: "\n",
                         position: (490, 66),
                        },
                        Expression {
                         expression: FunctionApplication {
                          function: Variable {
                           identifier: "mkSecretReplacement",
                           position: (491, 19),
                          },
                          arguments: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (491, 39),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "settings",
                               position: (491, 43),
                              },
                              Raw {
                               content: "imap",
                               position: (491, 52),
                              },
                              Raw {
                               content: "password",
                               position: (491, 57),
                              },
                             ],
                            },
                            default: None,
                           },
                          ],
                         },
                        },
                        Raw {
                         content: "\n",
                         position: (491, 66),
                        },
                        Expression {
                         expression: FunctionApplication {
                          function: Variable {
                           identifier: "mkSecretReplacement",
                           position: (492, 19),
                          },
                          arguments: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (492, 39),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "settings",
                               position: (492, 43),
                              },
                              Raw {
                               content: "elasticsearch",
                               position: (492, 52),
                              },
                              Raw {
                               content: "password",
                               position: (492, 66),
                              },
                             ],
                            },
                            default: None,
                           },
                          ],
                         },
                        },
                        Raw {
                         content: "\n",
                         position: (492, 75),
                        },
                        Expression {
                         expression: FunctionApplication {
                          function: Variable {
                           identifier: "mkSecretReplacement",
                           position: (493, 19),
                          },
                          arguments: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (493, 39),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "settings",
                               position: (493, 43),
                              },
                              Raw {
                               content: "kafka",
                               position: (493, 52),
                              },
                              Raw {
                               content: "password",
                               position: (493, 58),
                              },
                             ],
                            },
                            default: None,
                           },
                          ],
                         },
                        },
                        Raw {
                         content: "\n",
                         position: (493, 67),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "lib",
                         position: (494, 20),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "optionalString",
                           position: (494, 24),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (494, 39),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "provision",
                            position: (494, 43),
                           },
                           Raw {
                            content: "localMail",
                            position: (494, 53),
                           },
                           Raw {
                            content: "enable",
                            position: (494, 63),
                           },
                          ],
                         },
                         default: None,
                        },
                        String {
                         parts: [
                          Raw {
                           content: "openssl rand -hex 64 >/run/parsedmarc/dmarc_user_passwd\nreplace-secret '@imap-password@' '/run/parsedmarc/dmarc_user_passwd' /run/parsedmarc/parsedmarc.ini\necho \"Setting new randomized password for user ",
                           position: (495, 1),
                          },
                          Raw {
                           content: "'",
                           position: (497, 64),
                          },
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (497, 67),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "provision",
                               position: (497, 71),
                              },
                              Raw {
                               content: "localMail",
                               position: (497, 81),
                              },
                              Raw {
                               content: "recipientName",
                               position: (497, 91),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "'.\"\ncat <(echo -n \"",
                           position: (497, 105),
                          },
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (498, 34),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "provision",
                               position: (498, 38),
                              },
                              Raw {
                               content: "localMail",
                               position: (498, 48),
                              },
                              Raw {
                               content: "recipientName",
                               position: (498, 58),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: ":\") /run/parsedmarc/dmarc_user_passwd | chpasswd\n",
                           position: (498, 72),
                          },
                         ],
                        },
                       ],
                      },
                     ],
                     position: (494, 18),
                    },
                   ),
                  ],
                  target: String {
                   parts: [
                    Raw {
                     content: "+",
                     position: (501, 16),
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (501, 19),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "writeShellScript",
                          position: (501, 24),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "parsedmarc-start-pre-full-privileges",
                          position: (501, 42),
                         },
                        ],
                       },
                       Variable {
                        identifier: "startPreFullPrivileges",
                        position: (501, 80),
                       },
                      ],
                     },
                    },
                   ],
                  },
                  position: (482, 28),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Type",
                    position: (502, 13),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "simple",
                    position: (502, 21),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "User",
                    position: (503, 13),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "parsedmarc",
                    position: (503, 21),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Group",
                    position: (504, 13),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "parsedmarc",
                    position: (504, 22),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "DynamicUser",
                    position: (505, 13),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (505, 27),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RuntimeDirectory",
                    position: (506, 13),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "parsedmarc",
                    position: (506, 33),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RuntimeDirectoryMode",
                    position: (507, 13),
                   },
                  ],
                 },
                 Int {
                  value: 700,
                  position: (507, 36),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "CapabilityBoundingSet",
                    position: (508, 13),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "PrivateDevices",
                    position: (509, 13),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (509, 30),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "PrivateMounts",
                    position: (510, 13),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (510, 29),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "PrivateUsers",
                    position: (511, 13),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (511, 28),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectClock",
                    position: (512, 13),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (512, 28),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectControlGroups",
                    position: (513, 13),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (513, 36),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectHome",
                    position: (514, 13),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (514, 27),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectHostname",
                    position: (515, 13),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (515, 31),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectKernelLogs",
                    position: (516, 13),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (516, 33),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectKernelModules",
                    position: (517, 13),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (517, 36),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectKernelTunables",
                    position: (518, 13),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (518, 37),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectProc",
                    position: (519, 13),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "invisible",
                    position: (519, 28),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProcSubset",
                    position: (520, 13),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "pid",
                    position: (520, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "SystemCallFilter",
                    position: (521, 13),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "@system-service",
                      position: (521, 35),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "~@privileged",
                      position: (521, 53),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "~@resources",
                      position: (521, 68),
                     },
                    ],
                   },
                  ],
                  position: (521, 32),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RestrictAddressFamilies",
                    position: (522, 13),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "AF_UNIX",
                      position: (522, 42),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "AF_INET",
                      position: (522, 52),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "AF_INET6",
                      position: (522, 62),
                     },
                    ],
                   },
                  ],
                  position: (522, 39),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RestrictRealtime",
                    position: (523, 13),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (523, 32),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RestrictNamespaces",
                    position: (524, 13),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (524, 34),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "MemoryDenyWriteExecute",
                    position: (525, 13),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (525, 38),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "LockPersonality",
                    position: (526, 13),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (526, 31),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "SystemCallArchitectures",
                    position: (527, 13),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "native",
                    position: (527, 40),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStart",
                    position: (528, 13),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "pkgs",
                      position: (528, 28),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "python3Packages",
                        position: (528, 33),
                       },
                       Raw {
                        content: "parsedmarc",
                        position: (528, 49),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/bin/parsedmarc -c /run/parsedmarc/parsedmarc.ini",
                    position: (528, 60),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (481, 27),
              },
             ),
            ],
            recursive: false,
            position: (477, 9),
           },
           position: (465, 7),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "users",
             position: (532, 5),
            },
            Raw {
             content: "users",
             position: (532, 11),
            },
            Expression {
             expression: PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (532, 19),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "provision",
                 position: (532, 23),
                },
                Raw {
                 content: "localMail",
                 position: (532, 33),
                },
                Raw {
                 content: "recipientName",
                 position: (532, 43),
                },
               ],
              },
              default: None,
             },
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (532, 60),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "mkIf",
               position: (532, 64),
              },
             ],
            },
            default: None,
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (532, 69),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "provision",
                position: (532, 73),
               },
               Raw {
                content: "localMail",
                position: (532, 83),
               },
               Raw {
                content: "enable",
                position: (532, 93),
               },
              ],
             },
             default: None,
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "isNormalUser",
                  position: (533, 7),
                 },
                ],
               },
               Variable {
                identifier: "true",
                position: (533, 22),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (534, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "DMARC mail recipient",
                  position: (534, 22),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (532, 100),
            },
           ],
          },
         ),
        ],
        recursive: false,
        position: (366, 32),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "meta",
        position: (540, 3),
       },
       Raw {
        content: "doc",
        position: (540, 8),
       },
      ],
     },
     Path {
      parts: [
       Raw {
        content: "./parsedmarc.xml",
        position: (540, 14),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "meta",
        position: (541, 3),
       },
       Raw {
        content: "maintainers",
        position: (541, 8),
       },
      ],
     },
     List {
      elements: [
       PropertyAccess {
        expression: Variable {
         identifier: "lib",
         position: (541, 24),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "maintainers",
           position: (541, 28),
          },
          Raw {
           content: "talyz",
           position: (541, 40),
          },
         ],
        },
        default: None,
       },
      ],
      position: (541, 22),
     },
    ),
   ],
   recursive: false,
   position: (8, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}