---
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: With {
  expression: Variable {
   identifier: "lib",
   position: (3, 6),
  },
  target: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cfg",
        position: (6, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (6, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (6, 16),
        },
        Raw {
         content: "matrix-synapse",
         position: (6, 25),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "opt",
        position: (7, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "options",
       position: (7, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (7, 17),
        },
        Raw {
         content: "matrix-synapse",
         position: (7, 26),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "pg",
        position: (8, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (8, 8),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (8, 15),
        },
        Raw {
         content: "postgresql",
         position: (8, 24),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "usePostgresql",
        position: (9, 3),
       },
      ],
     },
     BinaryOperation {
      operator: EqualTo,
      operands: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (9, 19),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "database_type",
           position: (9, 23),
          },
         ],
        },
        default: None,
       },
       String {
        parts: [
         Raw {
          content: "psycopg2",
          position: (9, 41),
         },
        ],
       },
      ],
      position: (9, 37),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "logConfigFile",
        position: (10, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (10, 19),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (10, 24),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "log_config.yaml",
          position: (10, 35),
         },
        ],
       },
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (10, 52),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "logConfig",
           position: (10, 56),
          },
         ],
        },
        default: None,
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkResource",
        position: (11, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "r",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: String {
       parts: [
        Raw {
         content: "{names: ",
         position: (11, 21),
        },
        Expression {
         expression: FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "builtins",
            position: (11, 31),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "toJSON",
              position: (11, 40),
             },
            ],
           },
           default: None,
          },
          arguments: [
           PropertyAccess {
            expression: Variable {
             identifier: "r",
             position: (11, 47),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "names",
               position: (11, 49),
              },
             ],
            },
            default: None,
           },
          ],
         },
        },
        Raw {
         content: ", compress: ",
         position: (11, 55),
        },
        Expression {
         expression: FunctionApplication {
          function: Variable {
           identifier: "boolToString",
           position: (11, 69),
          },
          arguments: [
           PropertyAccess {
            expression: Variable {
             identifier: "r",
             position: (11, 82),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "compress",
               position: (11, 84),
              },
             ],
            },
            default: None,
           },
          ],
         },
        },
        Raw {
         content: "}",
         position: (11, 93),
        },
       ],
      },
      position: (11, 16),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkListener",
        position: (12, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "l",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: String {
       parts: [
        Raw {
         content: "{port: ",
         position: (12, 21),
        },
        Expression {
         expression: FunctionApplication {
          function: Variable {
           identifier: "toString",
           position: (12, 30),
          },
          arguments: [
           PropertyAccess {
            expression: Variable {
             identifier: "l",
             position: (12, 39),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "port",
               position: (12, 41),
              },
             ],
            },
            default: None,
           },
          ],
         },
        },
        Raw {
         content: ", bind_address: \"",
         position: (12, 46),
        },
        Expression {
         expression: PropertyAccess {
          expression: Variable {
           identifier: "l",
           position: (12, 65),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "bind_address",
             position: (12, 67),
            },
           ],
          },
          default: None,
         },
        },
        Raw {
         content: "\", type: ",
         position: (12, 80),
        },
        Expression {
         expression: PropertyAccess {
          expression: Variable {
           identifier: "l",
           position: (12, 91),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "type",
             position: (12, 93),
            },
           ],
          },
          default: None,
         },
        },
        Raw {
         content: ", tls: ",
         position: (12, 98),
        },
        Expression {
         expression: FunctionApplication {
          function: Variable {
           identifier: "boolToString",
           position: (12, 107),
          },
          arguments: [
           PropertyAccess {
            expression: Variable {
             identifier: "l",
             position: (12, 120),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "tls",
               position: (12, 122),
              },
             ],
            },
            default: None,
           },
          ],
         },
        },
        Raw {
         content: ", x_forwarded: ",
         position: (12, 126),
        },
        Expression {
         expression: FunctionApplication {
          function: Variable {
           identifier: "boolToString",
           position: (12, 143),
          },
          arguments: [
           PropertyAccess {
            expression: Variable {
             identifier: "l",
             position: (12, 156),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "x_forwarded",
               position: (12, 158),
              },
             ],
            },
            default: None,
           },
          ],
         },
        },
        Raw {
         content: ", resources: [",
         position: (12, 170),
        },
        Expression {
         expression: FunctionApplication {
          function: Variable {
           identifier: "concatStringsSep",
           position: (12, 186),
          },
          arguments: [
           String {
            parts: [
             Raw {
              content: ",",
              position: (12, 204),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "map",
             position: (12, 208),
            },
            arguments: [
             Variable {
              identifier: "mkResource",
              position: (12, 212),
             },
             PropertyAccess {
              expression: Variable {
               identifier: "l",
               position: (12, 223),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "resources",
                 position: (12, 225),
                },
               ],
              },
              default: None,
             },
            ],
           },
          ],
         },
        },
        Raw {
         content: "]}",
         position: (12, 236),
        },
       ],
      },
      position: (12, 16),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "pluginsEnv",
        position: (13, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "cfg",
        position: (13, 16),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "package",
          position: (13, 20),
         },
         Raw {
          content: "python",
          position: (13, 28),
         },
         Raw {
          content: "buildEnv",
          position: (13, 35),
         },
         Raw {
          content: "override",
          position: (13, 44),
         },
        ],
       },
       default: None,
      },
      arguments: [
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "extraLibs",
             position: (14, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (14, 17),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "plugins",
              position: (14, 21),
             },
            ],
           },
           default: None,
          },
         ),
        ],
        recursive: false,
        position: (13, 53),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "configFile",
        position: (16, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (16, 16),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (16, 21),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "homeserver.yaml",
          position: (16, 32),
         },
        ],
       },
       String {
        parts: [
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (17, 3),
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (17, 19),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "tls_certificate_path",
                  position: (17, 23),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "null",
               position: (17, 47),
              },
             ],
             position: (17, 44),
            },
            String {
             parts: [
              Raw {
               content: "tls_certificate_path: \"",
               position: (18, 1),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (18, 26),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "tls_certificate_path",
                   position: (18, 30),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "\"\n",
               position: (18, 51),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (19, 4),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (20, 3),
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (20, 19),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "tls_private_key_path",
                  position: (20, 23),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "null",
               position: (20, 47),
              },
             ],
             position: (20, 44),
            },
            String {
             parts: [
              Raw {
               content: "tls_private_key_path: \"",
               position: (21, 1),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (21, 26),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "tls_private_key_path",
                   position: (21, 30),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "\"\n",
               position: (21, 51),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (22, 4),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (23, 3),
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (23, 19),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "tls_dh_params_path",
                  position: (23, 23),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "null",
               position: (23, 45),
              },
             ],
             position: (23, 42),
            },
            String {
             parts: [
              Raw {
               content: "tls_dh_params_path: \"",
               position: (24, 1),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (24, 24),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "tls_dh_params_path",
                   position: (24, 28),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "\"\n",
               position: (24, 47),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\nno_tls: ",
          position: (25, 4),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "boolToString",
            position: (26, 11),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (26, 24),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "no_tls",
                position: (26, 28),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (26, 35),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (27, 3),
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (27, 19),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "bind_port",
                  position: (27, 23),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "null",
               position: (27, 36),
              },
             ],
             position: (27, 33),
            },
            String {
             parts: [
              Raw {
               content: "bind_port: ",
               position: (28, 1),
              },
              Expression {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "toString",
                 position: (28, 14),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (28, 23),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bind_port",
                     position: (28, 27),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              },
              Raw {
               content: "\n",
               position: (28, 37),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (29, 4),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (30, 3),
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (30, 19),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "unsecure_port",
                  position: (30, 23),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "null",
               position: (30, 40),
              },
             ],
             position: (30, 37),
            },
            String {
             parts: [
              Raw {
               content: "unsecure_port: ",
               position: (31, 1),
              },
              Expression {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "toString",
                 position: (31, 18),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (31, 27),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "unsecure_port",
                     position: (31, 31),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              },
              Raw {
               content: "\n",
               position: (31, 45),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (32, 4),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (33, 3),
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (33, 19),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "bind_host",
                  position: (33, 23),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "null",
               position: (33, 36),
              },
             ],
             position: (33, 33),
            },
            String {
             parts: [
              Raw {
               content: "bind_host: \"",
               position: (34, 1),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (34, 15),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "bind_host",
                   position: (34, 19),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "\"\n",
               position: (34, 29),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\nserver_name: \"",
          position: (35, 4),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (36, 17),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "server_name",
              position: (36, 21),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\"\npid_file: \"/run/matrix-synapse.pid\"\n",
          position: (36, 33),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (38, 3),
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (38, 19),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "public_baseurl",
                  position: (38, 23),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "null",
               position: (38, 41),
              },
             ],
             position: (38, 38),
            },
            String {
             parts: [
              Raw {
               content: "public_baseurl: \"",
               position: (39, 1),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (39, 20),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "public_baseurl",
                   position: (39, 24),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "\"\n",
               position: (39, 39),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\nlisteners: [",
          position: (40, 4),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "concatStringsSep",
            position: (41, 15),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: ",",
               position: (41, 33),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "map",
              position: (41, 37),
             },
             arguments: [
              Variable {
               identifier: "mkListener",
               position: (41, 41),
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (41, 52),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "listeners",
                  position: (41, 56),
                 },
                ],
               },
               default: None,
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "]\ndatabase: {\n  name: \"",
          position: (41, 67),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (43, 12),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "database_type",
              position: (43, 16),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\",\n  args: {\n    ",
          position: (43, 30),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "concatStringsSep",
            position: (45, 7),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: ",\n    ",
               position: (45, 25),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mapAttrsToList",
              position: (46, 7),
             },
             arguments: [
              Function {
               argument: Some(
                "n",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: Function {
                argument: Some(
                 "v",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: String {
                 parts: [
                  Raw {
                   content: "\"",
                   position: (46, 30),
                  },
                  Expression {
                   expression: Variable {
                    identifier: "n",
                    position: (46, 34),
                   },
                  },
                  Raw {
                   content: "\": ",
                   position: (46, 36),
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "builtins",
                      position: (46, 42),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "toJSON",
                        position: (46, 51),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     Variable {
                      identifier: "v",
                      position: (46, 58),
                     },
                    ],
                   },
                  },
                 ],
                },
                position: (46, 26),
               },
               position: (46, 23),
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (46, 63),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "database_args",
                  position: (46, 67),
                 },
                ],
               },
               default: None,
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n  }\n}\nevent_cache_size: \"",
          position: (47, 7),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (50, 22),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "event_cache_size",
              position: (50, 26),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\"\nverbose: ",
          position: (50, 43),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (51, 12),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "verbose",
              position: (51, 16),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nlog_config: \"",
          position: (51, 24),
         },
         Expression {
          expression: Variable {
           identifier: "logConfigFile",
           position: (52, 16),
          },
         },
         Raw {
          content: "\"\nrc_messages_per_second: ",
          position: (52, 30),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (53, 27),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "rc_messages_per_second",
              position: (53, 31),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nrc_message_burst_count: ",
          position: (53, 54),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (54, 27),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "rc_message_burst_count",
              position: (54, 31),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nfederation_rc_window_size: ",
          position: (54, 54),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (55, 30),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "federation_rc_window_size",
              position: (55, 34),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nfederation_rc_sleep_limit: ",
          position: (55, 60),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (56, 30),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "federation_rc_sleep_limit",
              position: (56, 34),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nfederation_rc_sleep_delay: ",
          position: (56, 60),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (57, 30),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "federation_rc_sleep_delay",
              position: (57, 34),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nfederation_rc_reject_limit: ",
          position: (57, 60),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (58, 31),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "federation_rc_reject_limit",
              position: (58, 35),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nfederation_rc_concurrent: ",
          position: (58, 62),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (59, 29),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "federation_rc_concurrent",
              position: (59, 33),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nmedia_store_path: \"",
          position: (59, 58),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (60, 22),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "dataDir",
              position: (60, 26),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "/media\"\nuploads_path: \"",
          position: (60, 34),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (61, 18),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "dataDir",
              position: (61, 22),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "/uploads\"\nmax_upload_size: \"",
          position: (61, 30),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (62, 21),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "max_upload_size",
              position: (62, 25),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\"\nmax_image_pixels: \"",
          position: (62, 41),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (63, 22),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "max_image_pixels",
              position: (63, 26),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\"\ndynamic_thumbnails: ",
          position: (63, 43),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "boolToString",
            position: (64, 23),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (64, 36),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "dynamic_thumbnails",
                position: (64, 40),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\nurl_preview_enabled: ",
          position: (64, 59),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "boolToString",
            position: (65, 24),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (65, 37),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "url_preview_enabled",
                position: (65, 41),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (65, 61),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (66, 3),
           },
           arguments: [
            BinaryOperation {
             operator: EqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (66, 19),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "url_preview_enabled",
                  position: (66, 23),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "true",
               position: (66, 46),
              },
             ],
             position: (66, 43),
            },
            String {
             parts: [
              Raw {
               content: "url_preview_ip_range_blacklist: ",
               position: (67, 1),
              },
              Expression {
               expression: FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "builtins",
                  position: (67, 35),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "toJSON",
                    position: (67, 44),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (67, 51),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "url_preview_ip_range_blacklist",
                     position: (67, 55),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              },
              Raw {
               content: "\nurl_preview_ip_range_whitelist: ",
               position: (67, 86),
              },
              Expression {
               expression: FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "builtins",
                  position: (68, 35),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "toJSON",
                    position: (68, 44),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (68, 51),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "url_preview_ip_range_whitelist",
                     position: (68, 55),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              },
              Raw {
               content: "\nurl_preview_url_blacklist: ",
               position: (68, 86),
              },
              Expression {
               expression: FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "builtins",
                  position: (69, 30),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "toJSON",
                    position: (69, 39),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (69, 46),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "url_preview_url_blacklist",
                     position: (69, 50),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              },
              Raw {
               content: "\n",
               position: (69, 76),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\nrecaptcha_private_key: \"",
          position: (70, 4),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (71, 27),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "recaptcha_private_key",
              position: (71, 31),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\"\nrecaptcha_public_key: \"",
          position: (71, 53),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (72, 26),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "recaptcha_public_key",
              position: (72, 30),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\"\nenable_registration_captcha: ",
          position: (72, 51),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "boolToString",
            position: (73, 32),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (73, 45),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "enable_registration_captcha",
                position: (73, 49),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\nturn_uris: ",
          position: (73, 77),
         },
         Expression {
          expression: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "builtins",
             position: (74, 14),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "toJSON",
               position: (74, 23),
              },
             ],
            },
            default: None,
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (74, 30),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "turn_uris",
                position: (74, 34),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\nturn_shared_secret: \"",
          position: (74, 44),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (75, 24),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "turn_shared_secret",
              position: (75, 28),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\"\nenable_registration: ",
          position: (75, 47),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "boolToString",
            position: (76, 24),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (76, 37),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "enable_registration",
                position: (76, 41),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (76, 61),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (77, 3),
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (77, 19),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "registration_shared_secret",
                  position: (77, 23),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "null",
               position: (77, 53),
              },
             ],
             position: (77, 50),
            },
            String {
             parts: [
              Raw {
               content: "registration_shared_secret: \"",
               position: (78, 1),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (78, 32),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "registration_shared_secret",
                   position: (78, 36),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "\"\n",
               position: (78, 63),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\nrecaptcha_siteverify_api: \"https://www.google.com/recaptcha/api/siteverify\"\nturn_user_lifetime: \"",
          position: (79, 4),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (81, 24),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "turn_user_lifetime",
              position: (81, 28),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\"\nuser_creation_max_duration: ",
          position: (81, 47),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (82, 31),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "user_creation_max_duration",
              position: (82, 35),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nbcrypt_rounds: ",
          position: (82, 62),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (83, 18),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "bcrypt_rounds",
              position: (83, 22),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nallow_guest_access: ",
          position: (83, 36),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "boolToString",
            position: (84, 23),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (84, 36),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "allow_guest_access",
                position: (84, 40),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\n\naccount_threepid_delegates:\n  ",
          position: (84, 59),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (87, 5),
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (87, 21),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "account_threepid_delegates",
                  position: (87, 25),
                 },
                 Raw {
                  content: "email",
                  position: (87, 52),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "null",
               position: (87, 61),
              },
             ],
             position: (87, 58),
            },
            String {
             parts: [
              Raw {
               content: "email: ",
               position: (87, 68),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (87, 77),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "account_threepid_delegates",
                   position: (87, 81),
                  },
                  Raw {
                   content: "email",
                   position: (87, 108),
                  },
                 ],
                },
                default: None,
               },
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n  ",
          position: (87, 116),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (88, 5),
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (88, 21),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "account_threepid_delegates",
                  position: (88, 25),
                 },
                 Raw {
                  content: "msisdn",
                  position: (88, 52),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "null",
               position: (88, 62),
              },
             ],
             position: (88, 59),
            },
            String {
             parts: [
              Raw {
               content: "msisdn: ",
               position: (88, 69),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (88, 79),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "account_threepid_delegates",
                   position: (88, 83),
                  },
                  Raw {
                   content: "msisdn",
                   position: (88, 110),
                  },
                 ],
                },
                default: None,
               },
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n\nroom_prejoin_state:\n  disable_default_event_types: ",
          position: (88, 119),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "boolToString",
            position: (91, 34),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (91, 47),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "room_prejoin_state",
                position: (91, 51),
               },
               Raw {
                content: "disable_default_event_types",
                position: (91, 70),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\n  additional_event_types: ",
          position: (91, 98),
         },
         Expression {
          expression: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "builtins",
             position: (92, 29),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "toJSON",
               position: (92, 38),
              },
             ],
            },
            default: None,
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (92, 45),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "room_prejoin_state",
                position: (92, 49),
               },
               Raw {
                content: "additional_event_types",
                position: (92, 68),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (92, 91),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (93, 3),
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (93, 19),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "macaroon_secret_key",
                  position: (93, 23),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "null",
               position: (93, 46),
              },
             ],
             position: (93, 43),
            },
            String {
             parts: [
              Raw {
               content: "macaroon_secret_key: \"",
               position: (94, 1),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (94, 27),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "macaroon_secret_key",
                   position: (94, 31),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "\"\n",
               position: (94, 51),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\nexpire_access_token: ",
          position: (95, 4),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "boolToString",
            position: (96, 24),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (96, 37),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "expire_access_token",
                position: (96, 41),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\nenable_metrics: ",
          position: (96, 61),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "boolToString",
            position: (97, 19),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (97, 32),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "enable_metrics",
                position: (97, 36),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\nreport_stats: ",
          position: (97, 51),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "boolToString",
            position: (98, 17),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (98, 30),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "report_stats",
                position: (98, 34),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\nsigning_key_path: \"",
          position: (98, 47),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (99, 22),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "dataDir",
              position: (99, 26),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "/homeserver.signing.key\"\nkey_refresh_interval: \"",
          position: (99, 34),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (100, 26),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "key_refresh_interval",
              position: (100, 30),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\"\nperspectives:\n  servers: {\n    ",
          position: (100, 51),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "concatStringsSep",
            position: (103, 7),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "},\n",
               position: (103, 25),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mapAttrsToList",
              position: (103, 32),
             },
             arguments: [
              Function {
               argument: Some(
                "n",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: Function {
                argument: Some(
                 "v",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: String {
                 parts: [
                  Raw {
                   content: "\"",
                   position: (104, 1),
                  },
                  Expression {
                   expression: Variable {
                    identifier: "n",
                    position: (104, 8),
                   },
                  },
                  Raw {
                   content: "\": {\n  \"verify_keys\": {\n    ",
                   position: (104, 10),
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "concatStringsSep",
                     position: (106, 11),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "},\n",
                        position: (106, 29),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "mapAttrsToList",
                       position: (106, 36),
                      },
                      arguments: [
                       Function {
                        argument: Some(
                         "n",
                        ),
                        arguments: FunctionArguments {
                         arguments: [],
                         ellipsis: false,
                        },
                        definition: Function {
                         argument: Some(
                          "v",
                         ),
                         arguments: FunctionArguments {
                          arguments: [],
                          ellipsis: false,
                         },
                         definition: String {
                          parts: [
                           Raw {
                            content: "        \"",
                            position: (107, 1),
                           },
                           Expression {
                            expression: Variable {
                             identifier: "n",
                             position: (107, 12),
                            },
                           },
                           Raw {
                            content: "\": {\n  \"key\": \"",
                            position: (107, 14),
                           },
                           Expression {
                            expression: Variable {
                             identifier: "v",
                             position: (108, 21),
                            },
                           },
                           Raw {
                            content: "\"\n}",
                            position: (108, 23),
                           },
                          ],
                         },
                         position: (106, 55),
                        },
                        position: (106, 52),
                       },
                       Variable {
                        identifier: "v",
                        position: (109, 14),
                       },
                      ],
                     },
                    ],
                   },
                  },
                  Raw {
                   content: "\n  }\n",
                   position: (109, 17),
                  },
                 ],
                },
                position: (103, 51),
               },
               position: (103, 48),
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (111, 9),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "servers",
                  position: (111, 13),
                 },
                ],
               },
               default: None,
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n    }\n  }\nredaction_retention_period: ",
          position: (111, 22),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (114, 31),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (114, 40),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "redaction_retention_period",
                position: (114, 44),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\napp_service_config_files: ",
          position: (114, 71),
         },
         Expression {
          expression: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "builtins",
             position: (115, 29),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "toJSON",
               position: (115, 38),
              },
             ],
            },
            default: None,
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (115, 45),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "app_service_config_files",
                position: (115, 49),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\n\n",
          position: (115, 74),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (117, 3),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "extraConfig",
              position: (117, 7),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\n",
          position: (117, 19),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "hasLocalPostgresDB",
        position: (120, 3),
       },
      ],
     },
     LetIn {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "args",
           position: (120, 28),
          },
         ],
        },
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (120, 35),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "database_args",
            position: (120, 39),
           },
          ],
         },
         default: None,
        },
       ),
      ],
      target: BinaryOperation {
       operator: LogicalAnd,
       operands: [
        Variable {
         identifier: "usePostgresql",
         position: (121, 5),
        },
        BinaryOperation {
         operator: LogicalOr,
         operands: [
          UnaryOperation {
           operator: Not,
           operand: HasProperty {
            expression: Variable {
             identifier: "args",
             position: (121, 25),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "host",
               position: (121, 32),
              },
             ],
            },
            position: (121, 30),
           },
           position: (121, 23),
          },
          FunctionApplication {
           function: Variable {
            identifier: "elem",
            position: (121, 42),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "args",
              position: (121, 47),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "host",
                position: (121, 52),
               },
              ],
             },
             default: None,
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "localhost",
                 position: (121, 60),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "127.0.0.1",
                 position: (121, 72),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "::1",
                 position: (121, 84),
                },
               ],
              },
             ],
             position: (121, 57),
            },
           ],
          },
         ],
         position: (121, 38),
        },
       ],
       position: (121, 19),
      },
      position: (120, 24),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "registerNewMatrixUser",
        position: (123, 3),
       },
      ],
     },
     LetIn {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "isIpv6",
           position: (125, 7),
          },
         ],
        },
        Function {
         argument: Some(
          "x",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: BinaryOperation {
          operator: GreaterThan,
          operands: [
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "lib",
              position: (125, 19),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "length",
                position: (125, 23),
               },
              ],
             },
             default: None,
            },
            arguments: [
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "lib",
                position: (125, 31),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "splitString",
                  position: (125, 35),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: ":",
                  position: (125, 48),
                 },
                ],
               },
               Variable {
                identifier: "x",
                position: (125, 51),
               },
              ],
             },
            ],
           },
           Int {
            value: 1,
            position: (125, 56),
           },
          ],
          position: (125, 54),
         },
         position: (125, 16),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "listener",
           position: (126, 7),
          },
         ],
        },
        FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "lib",
           position: (127, 9),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "findFirst",
             position: (127, 13),
            },
           ],
          },
          default: None,
         },
         arguments: [
          Function {
           argument: Some(
            "listener",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "lib",
              position: (128, 21),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "any",
                position: (128, 25),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Function {
              argument: Some(
               "resource",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (129, 23),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "any",
                   position: (129, 27),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Function {
                 argument: Some(
                  "name",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   Variable {
                    identifier: "name",
                    position: (130, 21),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "client",
                      position: (130, 30),
                     },
                    ],
                   },
                  ],
                  position: (130, 26),
                 },
                 position: (130, 15),
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "resource",
                  position: (131, 15),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "names",
                    position: (131, 24),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
              position: (129, 13),
             },
             PropertyAccess {
              expression: Variable {
               identifier: "listener",
               position: (132, 13),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "resources",
                 position: (132, 22),
                },
               ],
              },
              default: None,
             },
            ],
           },
           position: (128, 11),
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (133, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "last",
               position: (133, 16),
              },
             ],
            },
            default: None,
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (133, 21),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "listeners",
                position: (133, 25),
               },
              ],
             },
             default: None,
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (133, 36),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "listeners",
              position: (133, 40),
             },
            ],
           },
           default: None,
          },
         ],
        },
       ),
      ],
      target: FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "pkgs",
         position: (135, 5),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "writeShellScriptBin",
           position: (135, 10),
          },
         ],
        },
        default: None,
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "matrix-synapse-register_new_matrix_user",
           position: (135, 31),
          },
         ],
        },
        String {
         parts: [
          Raw {
           content: "exec ",
           position: (136, 1),
          },
          Expression {
           expression: PropertyAccess {
            expression: Variable {
             identifier: "cfg",
             position: (136, 14),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "package",
               position: (136, 18),
              },
             ],
            },
            default: None,
           },
          },
          Raw {
           content: "/bin/register_new_matrix_user \\\n  $@ \\\n  ",
           position: (136, 26),
          },
          Expression {
           expression: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "lib",
              position: (138, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "concatMapStringsSep",
                position: (138, 15),
               },
              ],
             },
             default: None,
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: " ",
                position: (138, 36),
               },
              ],
             },
             Function {
              argument: Some(
               "x",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: String {
               parts: [
                Raw {
                 content: "-c ",
                 position: (138, 44),
                },
                Expression {
                 expression: Variable {
                  identifier: "x",
                  position: (138, 49),
                 },
                },
               ],
              },
              position: (138, 40),
             },
             BinaryOperation {
              operator: Concatenation,
              operands: [
               List {
                elements: [
                 Variable {
                  identifier: "configFile",
                  position: (138, 57),
                 },
                ],
                position: (138, 55),
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (138, 73),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "extraConfigFiles",
                   position: (138, 77),
                  },
                 ],
                },
                default: None,
               },
              ],
              position: (138, 70),
             },
            ],
           },
          },
          Raw {
           content: " \\\n  \"",
           position: (138, 95),
          },
          Expression {
           expression: PropertyAccess {
            expression: Variable {
             identifier: "listener",
             position: (139, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "type",
               position: (139, 21),
              },
             ],
            },
            default: None,
           },
          },
          Raw {
           content: "://",
           position: (139, 26),
          },
          Expression {
           expression: IfThenElse {
            predicate: FunctionApplication {
             function: Variable {
              identifier: "isIpv6",
              position: (140, 15),
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "listener",
                position: (140, 22),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "bind_address",
                  position: (140, 31),
                 },
                ],
               },
               default: None,
              },
             ],
            },
            then: String {
             parts: [
              Raw {
               content: "[",
               position: (141, 14),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "listener",
                 position: (141, 17),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "bind_address",
                   position: (141, 26),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "]",
               position: (141, 39),
              },
             ],
            },
            else_: String {
             parts: [
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "listener",
                 position: (143, 16),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "bind_address",
                   position: (143, 25),
                  },
                 ],
                },
                default: None,
               },
              },
             ],
            },
            position: (140, 11),
           },
          },
          Raw {
           content: ":",
           position: (144, 10),
          },
          Expression {
           expression: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (144, 13),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "toString",
                position: (144, 22),
               },
              ],
             },
             default: None,
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "listener",
               position: (144, 31),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "port",
                 position: (144, 40),
                },
               ],
              },
              default: None,
             },
            ],
           },
          },
          Raw {
           content: "/\"\n",
           position: (144, 45),
          },
         ],
        },
       ],
      },
      position: (124, 5),
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (147, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "services",
            position: (148, 5),
           },
           Raw {
            content: "matrix-synapse",
            position: (148, 14),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (149, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkEnableOption",
              position: (149, 16),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "matrix.org synapse",
                 position: (149, 32),
                },
               ],
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "configFile",
               position: (150, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (150, 20),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (151, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (151, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (151, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "readOnly",
                    position: (152, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (152, 20),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (153, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Path to the configuration file on the target system. Useful to configure e.g. workers\nthat also need this.\n",
                    position: (154, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (150, 29),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "package",
               position: (158, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (158, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (159, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (159, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (159, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (160, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (160, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "matrix-synapse",
                     position: (160, 24),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (161, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (161, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.matrix-synapse",
                      position: (161, 42),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (162, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Overridable attribute of the matrix synapse server package to use.\n",
                    position: (163, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (158, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "plugins",
               position: (166, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (166, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (167, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (167, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (167, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (167, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "package",
                       position: (167, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (168, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (168, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (169, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (169, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "with config.services.matrix-synapse.package.plugins; [\n  matrix-synapse-ldap3\n  matrix-synapse-pam\n];\n",
                      position: (170, 1),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (175, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "List of additional Matrix plugins to make available.\n",
                    position: (176, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (166, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "withJemalloc",
               position: (179, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (179, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (180, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (180, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (180, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (181, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (181, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (182, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to preload jemalloc to reduce memory fragmentation and overall usage.\n",
                    position: (183, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (179, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "no_tls",
               position: (186, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (186, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (187, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (187, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (187, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (188, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (188, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (189, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Don't bind to the https port\n",
                    position: (190, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (186, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "bind_port",
               position: (193, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (193, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (194, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (194, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (194, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (194, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "int",
                       position: (194, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (195, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (195, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (196, 9),
                   },
                  ],
                 },
                 Int {
                  value: 8448,
                  position: (196, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (197, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "DEPRECATED: Use listeners instead.\nThe port to listen for HTTPS requests on.\nFor when matrix traffic is sent directly to synapse.\n",
                    position: (198, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (193, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "unsecure_port",
               position: (203, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (203, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (204, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (204, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (204, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (204, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "int",
                       position: (204, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (205, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (205, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (206, 9),
                   },
                  ],
                 },
                 Int {
                  value: 8008,
                  position: (206, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (207, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "DEPRECATED: Use listeners instead.\nThe port to listen for HTTP requests on.\nFor when matrix traffic passes through loadbalancer that unwraps TLS.\n",
                    position: (208, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (203, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "bind_host",
               position: (213, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (213, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (214, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (214, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (214, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (214, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (214, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (215, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (215, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (216, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "DEPRECATED: Use listeners instead.\nLocal interface to listen on.\nThe empty string will cause synapse to listen on all interfaces.\n",
                    position: (217, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (213, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "tls_certificate_path",
               position: (222, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (222, 30),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (223, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (223, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (223, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (223, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (223, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (224, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (224, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (225, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/var/lib/matrix-synapse/homeserver.tls.crt",
                    position: (225, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (226, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "PEM encoded X509 certificate for TLS.\nYou can replace the self-signed certificate that synapse\nautogenerates on launch with your own SSL certificate + key pair\nif you like.  Any required intermediary certificates can be\nappended after the primary certificate in hierarchical order.\n",
                    position: (227, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (222, 39),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "tls_private_key_path",
               position: (234, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (234, 30),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (235, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (235, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (235, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (235, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (235, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (236, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (236, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (237, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/var/lib/matrix-synapse/homeserver.tls.key",
                    position: (237, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (238, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "PEM encoded private key for TLS. Specify null if synapse is not\nspeaking TLS directly.\n",
                    position: (239, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (234, 39),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "tls_dh_params_path",
               position: (243, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (243, 28),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (244, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (244, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (244, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (244, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (244, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (245, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (245, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (246, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/var/lib/matrix-synapse/homeserver.tls.dh",
                    position: (246, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (247, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "PEM dh parameters for ephemeral keys\n",
                    position: (248, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (243, 37),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "server_name",
               position: (251, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (251, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (252, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (252, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (252, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (253, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "example.com",
                    position: (253, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (254, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "config",
                   position: (254, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "networking",
                     position: (254, 26),
                    },
                    Raw {
                     content: "hostName",
                     position: (254, 37),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (255, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (255, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "config.networking.hostName",
                      position: (255, 42),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (256, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The domain name of the server, with optional explicit port.\nThis is used by remote servers to look up the server address.\nThis is also the last part of your UserID.\n\nThe server_name cannot be changed later so it is important to configure this correctly before you start Synapse.\n",
                    position: (257, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (251, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "public_baseurl",
               position: (264, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (264, 24),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (265, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (265, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (265, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (265, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (265, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (266, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (266, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (267, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "https://example.com:8448/",
                    position: (267, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (268, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The public-facing base URL for the client API (not including _matrix/...)\n",
                    position: (269, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (264, 33),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "listeners",
               position: (272, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (272, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (273, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (273, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (273, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (273, 30),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "submodule",
                        position: (273, 36),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "options",
                           position: (274, 11),
                          },
                         ],
                        },
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "port",
                              position: (275, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (275, 20),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (276, 15),
                                  },
                                 ],
                                },
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (276, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "port",
                                    position: (276, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "example",
                                   position: (277, 15),
                                  },
                                 ],
                                },
                                Int {
                                 value: 8448,
                                 position: (277, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (278, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "The port to listen for HTTP(S) requests on.\n",
                                   position: (279, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (275, 29),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "bind_address",
                              position: (282, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (282, 28),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (283, 15),
                                  },
                                 ],
                                },
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (283, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "str",
                                    position: (283, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (284, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "example",
                                   position: (285, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "203.0.113.42",
                                   position: (285, 26),
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (286, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "Local interface to listen on.\nThe empty string will cause synapse to listen on all interfaces.\n",
                                   position: (287, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (282, 37),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (291, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (291, 20),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (292, 15),
                                  },
                                 ],
                                },
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (292, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "str",
                                    position: (292, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (293, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "http",
                                   position: (293, 26),
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (294, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "Type of listener.\n",
                                   position: (295, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (291, 29),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "tls",
                              position: (298, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (298, 19),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (299, 15),
                                  },
                                 ],
                                },
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (299, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "bool",
                                    position: (299, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (300, 15),
                                  },
                                 ],
                                },
                                Variable {
                                 identifier: "true",
                                 position: (300, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (301, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "Whether to listen for HTTPS connections rather than HTTP.\n",
                                   position: (302, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (298, 28),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "x_forwarded",
                              position: (305, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (305, 27),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (306, 15),
                                  },
                                 ],
                                },
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (306, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "bool",
                                    position: (306, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (307, 15),
                                  },
                                 ],
                                },
                                Variable {
                                 identifier: "false",
                                 position: (307, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (308, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "Use the X-Forwarded-For (XFF) header as the client IP and not the\nactual client IP.\n",
                                   position: (309, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (305, 36),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "resources",
                              position: (313, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (313, 25),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (314, 15),
                                  },
                                 ],
                                },
                                FunctionApplication {
                                 function: PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (314, 22),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "listOf",
                                     position: (314, 28),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 arguments: [
                                  FunctionApplication {
                                   function: PropertyAccess {
                                    expression: Variable {
                                     identifier: "types",
                                     position: (314, 36),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "submodule",
                                       position: (314, 42),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                   arguments: [
                                    Map {
                                     bindings: [
                                      KeyValue(
                                       AttributePath {
                                        attributes: [
                                         Raw {
                                          content: "options",
                                          position: (315, 17),
                                         },
                                        ],
                                       },
                                       Map {
                                        bindings: [
                                         KeyValue(
                                          AttributePath {
                                           attributes: [
                                            Raw {
                                             content: "names",
                                             position: (316, 19),
                                            },
                                           ],
                                          },
                                          FunctionApplication {
                                           function: Variable {
                                            identifier: "mkOption",
                                            position: (316, 27),
                                           },
                                           arguments: [
                                            Map {
                                             bindings: [
                                              KeyValue(
                                               AttributePath {
                                                attributes: [
                                                 Raw {
                                                  content: "type",
                                                  position: (317, 21),
                                                 },
                                                ],
                                               },
                                               FunctionApplication {
                                                function: PropertyAccess {
                                                 expression: Variable {
                                                  identifier: "types",
                                                  position: (317, 28),
                                                 },
                                                 attribute_path: AttributePath {
                                                  attributes: [
                                                   Raw {
                                                    content: "listOf",
                                                    position: (317, 34),
                                                   },
                                                  ],
                                                 },
                                                 default: None,
                                                },
                                                arguments: [
                                                 PropertyAccess {
                                                  expression: Variable {
                                                   identifier: "types",
                                                   position: (317, 41),
                                                  },
                                                  attribute_path: AttributePath {
                                                   attributes: [
                                                    Raw {
                                                     content: "str",
                                                     position: (317, 47),
                                                    },
                                                   ],
                                                  },
                                                  default: None,
                                                 },
                                                ],
                                               },
                                              ),
                                              KeyValue(
                                               AttributePath {
                                                attributes: [
                                                 Raw {
                                                  content: "description",
                                                  position: (318, 21),
                                                 },
                                                ],
                                               },
                                               String {
                                                parts: [
                                                 Raw {
                                                  content: "List of resources to host on this listener.\n",
                                                  position: (319, 1),
                                                 },
                                                ],
                                               },
                                              ),
                                              KeyValue(
                                               AttributePath {
                                                attributes: [
                                                 Raw {
                                                  content: "example",
                                                  position: (321, 21),
                                                 },
                                                ],
                                               },
                                               List {
                                                elements: [
                                                 String {
                                                  parts: [
                                                   Raw {
                                                    content: "client",
                                                    position: (321, 33),
                                                   },
                                                  ],
                                                 },
                                                 String {
                                                  parts: [
                                                   Raw {
                                                    content: "federation",
                                                    position: (321, 42),
                                                   },
                                                  ],
                                                 },
                                                ],
                                                position: (321, 31),
                                               },
                                              ),
                                             ],
                                             recursive: false,
                                             position: (316, 36),
                                            },
                                           ],
                                          },
                                         ),
                                         KeyValue(
                                          AttributePath {
                                           attributes: [
                                            Raw {
                                             content: "compress",
                                             position: (323, 19),
                                            },
                                           ],
                                          },
                                          FunctionApplication {
                                           function: Variable {
                                            identifier: "mkOption",
                                            position: (323, 30),
                                           },
                                           arguments: [
                                            Map {
                                             bindings: [
                                              KeyValue(
                                               AttributePath {
                                                attributes: [
                                                 Raw {
                                                  content: "type",
                                                  position: (324, 21),
                                                 },
                                                ],
                                               },
                                               PropertyAccess {
                                                expression: Variable {
                                                 identifier: "types",
                                                 position: (324, 28),
                                                },
                                                attribute_path: AttributePath {
                                                 attributes: [
                                                  Raw {
                                                   content: "bool",
                                                   position: (324, 34),
                                                  },
                                                 ],
                                                },
                                                default: None,
                                               },
                                              ),
                                              KeyValue(
                                               AttributePath {
                                                attributes: [
                                                 Raw {
                                                  content: "description",
                                                  position: (325, 21),
                                                 },
                                                ],
                                               },
                                               String {
                                                parts: [
                                                 Raw {
                                                  content: "Should synapse compress HTTP responses to clients that support it?\nThis should be disabled if running synapse behind a load balancer\nthat can do automatic compression.\n",
                                                  position: (326, 1),
                                                 },
                                                ],
                                               },
                                              ),
                                             ],
                                             recursive: false,
                                             position: (323, 39),
                                            },
                                           ],
                                          },
                                         ),
                                        ],
                                        recursive: false,
                                        position: (315, 27),
                                       },
                                      ),
                                     ],
                                     recursive: false,
                                     position: (314, 52),
                                    },
                                   ],
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (333, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "List of HTTP resources to serve on this listener.\n",
                                   position: (334, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (313, 34),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (274, 21),
                        },
                       ),
                      ],
                      recursive: false,
                      position: (273, 46),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (339, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "port",
                         position: (340, 11),
                        },
                       ],
                      },
                      Int {
                       value: 8448,
                       position: (340, 18),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "bind_address",
                         position: (341, 11),
                        },
                       ],
                      },
                      String {
                       parts: [],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (342, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "http",
                         position: (342, 19),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "tls",
                         position: (343, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "true",
                       position: (343, 17),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "x_forwarded",
                         position: (344, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (344, 25),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "resources",
                         position: (345, 11),
                        },
                       ],
                      },
                      List {
                       elements: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "names",
                              position: (346, 15),
                             },
                            ],
                           },
                           List {
                            elements: [
                             String {
                              parts: [
                               Raw {
                                content: "client",
                                position: (346, 25),
                               },
                              ],
                             },
                            ],
                            position: (346, 23),
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "compress",
                              position: (346, 35),
                             },
                            ],
                           },
                           Variable {
                            identifier: "true",
                            position: (346, 46),
                           },
                          ),
                         ],
                         recursive: false,
                         position: (346, 13),
                        },
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "names",
                              position: (347, 15),
                             },
                            ],
                           },
                           List {
                            elements: [
                             String {
                              parts: [
                               Raw {
                                content: "federation",
                                position: (347, 25),
                               },
                              ],
                             },
                            ],
                            position: (347, 23),
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "compress",
                              position: (347, 39),
                             },
                            ],
                           },
                           Variable {
                            identifier: "false",
                            position: (347, 50),
                           },
                          ),
                         ],
                         recursive: false,
                         position: (347, 13),
                        },
                       ],
                       position: (345, 23),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (339, 20),
                   },
                  ],
                  position: (339, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (350, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "List of ports that Synapse should listen on, their purpose and their configuration.\n",
                    position: (351, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (272, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "verbose",
               position: (354, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (354, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (355, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (355, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (355, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (356, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "0",
                    position: (356, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (357, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Logging verbosity level.",
                    position: (357, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (354, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "rc_messages_per_second",
               position: (359, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (359, 32),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (360, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (360, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (360, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (361, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "0.2",
                    position: (361, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (362, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Number of messages a client can send per second",
                    position: (362, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (359, 41),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "rc_message_burst_count",
               position: (364, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (364, 32),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (365, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (365, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (365, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (366, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "10.0",
                    position: (366, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (367, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Number of message a client can send before being throttled",
                    position: (367, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (364, 41),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "federation_rc_window_size",
               position: (369, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (369, 35),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (370, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (370, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (370, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (371, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "1000",
                    position: (371, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (372, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The federation window size in milliseconds",
                    position: (372, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (369, 44),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "federation_rc_sleep_limit",
               position: (374, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (374, 35),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (375, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (375, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (375, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (376, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "10",
                    position: (376, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (377, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The number of federation requests from a single server in a window\nbefore the server will delay processing the request.\n",
                    position: (378, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (374, 44),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "federation_rc_sleep_delay",
               position: (382, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (382, 35),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (383, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (383, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (383, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (384, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "500",
                    position: (384, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (385, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The duration in milliseconds to delay processing events from\nremote servers by if they go over the sleep limit.\n",
                    position: (386, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (382, 44),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "federation_rc_reject_limit",
               position: (390, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (390, 36),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (391, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (391, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (391, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (392, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "50",
                    position: (392, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (393, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The maximum number of concurrent federation requests allowed\nfrom a single server\n",
                    position: (394, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (390, 45),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "federation_rc_concurrent",
               position: (398, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (398, 34),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (399, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (399, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (399, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (400, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "3",
                    position: (400, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (401, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The number of federation requests to concurrently process from a single server",
                    position: (401, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (398, 43),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "database_type",
               position: (403, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (403, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (404, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (404, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "enum",
                      position: (404, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "sqlite3",
                        position: (404, 30),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "psycopg2",
                        position: (404, 40),
                       },
                      ],
                     },
                    ],
                    position: (404, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (405, 9),
                   },
                  ],
                 },
                 IfThenElse {
                  predicate: FunctionApplication {
                   function: Variable {
                    identifier: "versionAtLeast",
                    position: (405, 22),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (405, 37),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "system",
                        position: (405, 44),
                       },
                       Raw {
                        content: "stateVersion",
                        position: (405, 51),
                       },
                      ],
                     },
                     default: None,
                    },
                    String {
                     parts: [
                      Raw {
                       content: "18.03",
                       position: (405, 65),
                      },
                     ],
                    },
                   ],
                  },
                  then: String {
                   parts: [
                    Raw {
                     content: "psycopg2",
                     position: (406, 17),
                    },
                   ],
                  },
                  else_: String {
                   parts: [
                    Raw {
                     content: "sqlite3",
                     position: (407, 17),
                    },
                   ],
                  },
                  position: (405, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (408, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (408, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "if versionAtLeast config.system.stateVersion \"18.03\"\n  then \"psycopg2\"\n  else \"sqlite3\"\n",
                      position: (409, 1),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (413, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The database engine name. Can be sqlite or psycopg2.\n",
                    position: (414, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (403, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "database_name",
               position: (417, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (417, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (418, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (418, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (418, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (419, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "matrix-synapse",
                    position: (419, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (420, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Database name.",
                    position: (420, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (417, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "database_user",
               position: (422, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (422, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (423, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (423, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (423, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (424, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "matrix-synapse",
                    position: (424, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (425, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Database user name.",
                    position: (425, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (422, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "database_args",
               position: (427, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (427, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (428, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (428, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "attrs",
                     position: (428, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (429, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "sqlite3",
                        position: (430, 11),
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "database",
                           position: (430, 23),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (430, 37),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "dataDir",
                               position: (430, 41),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "/homeserver.db",
                           position: (430, 49),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (430, 21),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "psycopg2",
                        position: (431, 11),
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "user",
                           position: (432, 13),
                          },
                         ],
                        },
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (432, 20),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "database_user",
                            position: (432, 24),
                           },
                          ],
                         },
                         default: None,
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "database",
                           position: (433, 13),
                          },
                         ],
                        },
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (433, 24),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "database_name",
                            position: (433, 28),
                           },
                          ],
                         },
                         default: None,
                        },
                       ),
                      ],
                      recursive: false,
                      position: (431, 22),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (429, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (435, 13),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "database_type",
                         position: (435, 17),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (436, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalDocBook",
                   position: (436, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "<variablelist>\n  <varlistentry>\n    <term>using sqlite3</term>\n    <listitem>\n      <programlisting>\n        { database = \"",
                      position: (437, 1),
                     },
                     Raw {
                      content: "$",
                      position: (442, 33),
                     },
                     Raw {
                      content: "{config.",
                      position: (442, 36),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "opt",
                        position: (442, 46),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "dataDir",
                          position: (442, 50),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "}/homeserver.db\"; }\n      </programlisting>\n    </listitem>\n  </varlistentry>\n  <varlistentry>\n    <term>using psycopg2</term>\n    <listitem>\n      <programlisting>\n        psycopg2 = {\n          user = config.",
                      position: (442, 58),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "opt",
                        position: (451, 37),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "database_user",
                          position: (451, 41),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: ";\n          database = config.",
                      position: (451, 55),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "opt",
                        position: (452, 41),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "database_name",
                          position: (452, 45),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: ";\n        }\n      </programlisting>\n    </listitem>\n  </varlistentry>\n</variablelist>\n",
                      position: (452, 59),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (459, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Arguments to pass to the engine.\n",
                    position: (460, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (427, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "event_cache_size",
               position: (463, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (463, 26),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (464, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (464, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (464, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (465, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "10K",
                    position: (465, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (466, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Number of events to cache in memory.",
                    position: (466, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (463, 35),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "url_preview_enabled",
               position: (468, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (468, 29),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (469, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (469, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (469, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (470, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (470, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (471, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Is the preview URL API enabled?  If enabled, you *must* specify an\nexplicit url_preview_ip_range_blacklist of IPs that the spider is\ndenied from accessing.\n",
                    position: (472, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (468, 38),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "url_preview_ip_range_blacklist",
               position: (477, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (477, 40),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (478, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (478, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (478, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (478, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (478, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (479, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "127.0.0.0/8",
                      position: (480, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "10.0.0.0/8",
                      position: (481, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "172.16.0.0/12",
                      position: (482, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "192.168.0.0/16",
                      position: (483, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "100.64.0.0/10",
                      position: (484, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "169.254.0.0/16",
                      position: (485, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "::1/128",
                      position: (486, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "fe80::/64",
                      position: (487, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "fc00::/7",
                      position: (488, 12),
                     },
                    ],
                   },
                  ],
                  position: (479, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (490, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "List of IP address CIDR ranges that the URL preview spider is denied\nfrom accessing.\n",
                    position: (491, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (477, 49),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "url_preview_ip_range_whitelist",
               position: (495, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (495, 40),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (496, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (496, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (496, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (496, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (496, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (497, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (497, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (498, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "List of IP address CIDR ranges that the URL preview spider is allowed\nto access even if they are specified in\nurl_preview_ip_range_blacklist.\n",
                    position: (499, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (495, 49),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "url_preview_url_blacklist",
               position: (504, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (504, 35),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (505, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (505, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (505, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (505, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (505, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (506, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (506, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (507, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Optional list of URL matches that the URL preview spider is\ndenied from accessing.\n",
                    position: (508, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (504, 44),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "recaptcha_private_key",
               position: (512, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (512, 31),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (513, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (513, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (513, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (514, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (515, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "This Home Server's ReCAPTCHA private key.\n",
                    position: (516, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (512, 40),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "recaptcha_public_key",
               position: (519, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (519, 30),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (520, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (520, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (520, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (521, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (522, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "This Home Server's ReCAPTCHA public key.\n",
                    position: (523, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (519, 39),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable_registration_captcha",
               position: (526, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (526, 37),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (527, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (527, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (527, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (528, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (528, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (529, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Enables ReCaptcha checks when registering, preventing signup\nunless a captcha is answered. Requires a valid ReCaptcha\npublic/private key.\n",
                    position: (530, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (526, 46),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "turn_uris",
               position: (535, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (535, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (536, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (536, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (536, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (536, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (536, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (537, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (537, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (538, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The public URIs of the TURN server to give to clients\n",
                    position: (539, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (535, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "turn_shared_secret",
               position: (542, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (542, 28),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (543, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (543, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (543, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (544, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (545, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The shared secret used to compute passwords for the TURN server\n",
                    position: (546, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (542, 37),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "turn_user_lifetime",
               position: (549, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (549, 28),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (550, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (550, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (550, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (551, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "1h",
                    position: (551, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (552, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "How long generated TURN credentials last",
                    position: (552, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (549, 37),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable_registration",
               position: (554, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (554, 29),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (555, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (555, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (555, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (556, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (556, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (557, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Enable registration for new users.\n",
                    position: (558, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (554, 38),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "registration_shared_secret",
               position: (561, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (561, 36),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (562, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (562, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (562, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (562, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (562, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (563, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (563, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (564, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "If set, allows registration by anyone who also has the shared\nsecret, even if registration is otherwise disabled.\n",
                    position: (565, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (561, 45),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable_metrics",
               position: (569, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (569, 24),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (570, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (570, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (570, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (571, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (571, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (572, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Enable collection and rendering of performance metrics\n",
                    position: (573, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (569, 33),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "report_stats",
               position: (576, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (576, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (577, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (577, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (577, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (578, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (578, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (579, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
               ],
               recursive: false,
               position: (576, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "servers",
               position: (581, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (581, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (582, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (582, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "attrsOf",
                      position: (582, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (582, 31),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "attrsOf",
                        position: (582, 37),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (582, 45),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "str",
                         position: (582, 51),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (583, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Expression {
                       expression: String {
                        parts: [
                         Raw {
                          content: "matrix.org",
                          position: (584, 12),
                         },
                        ],
                       },
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Expression {
                          expression: String {
                           parts: [
                            Raw {
                             content: "ed25519:auto",
                             position: (585, 14),
                            },
                           ],
                          },
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "Noi6WqcDj0QmPxCNQqgezwTlBKrfqehY1u2FyWP9uYw",
                          position: (585, 31),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (584, 26),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (583, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (588, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The trusted servers to download signing keys from.\n",
                    position: (589, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (581, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "max_upload_size",
               position: (592, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (592, 25),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (593, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (593, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (593, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (594, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "10M",
                    position: (594, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (595, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The largest allowed upload size in bytes",
                    position: (595, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (592, 34),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "max_image_pixels",
               position: (597, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (597, 26),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (598, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (598, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (598, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (599, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "32M",
                    position: (599, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (600, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Maximum number of pixels that will be thumbnailed",
                    position: (600, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (597, 35),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "dynamic_thumbnails",
               position: (602, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (602, 28),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (603, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (603, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (603, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (604, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (604, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (605, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to generate new thumbnails on the fly to precisely match\nthe resolution requested by the client. If true then whenever\na new resolution is requested by the client the server will\ngenerate a new thumbnail. If false the server will pick a thumbnail\nfrom a precalculated list.\n",
                    position: (606, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (602, 37),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "user_creation_max_duration",
               position: (613, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (613, 36),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (614, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (614, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (614, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (615, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "1209600000",
                    position: (615, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (616, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Sets the expiry for the short term user creation in\nmilliseconds. The default value is two weeks.\n",
                    position: (617, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (613, 45),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "bcrypt_rounds",
               position: (621, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (621, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (622, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (622, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (622, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (623, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "12",
                    position: (623, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (624, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Set the number of bcrypt rounds used to generate password hash.\nLarger numbers increase the work factor needed to generate the hash.\n",
                    position: (625, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (621, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "allow_guest_access",
               position: (629, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (629, 28),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (630, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (630, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (630, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (631, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (631, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (632, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Allows users to register as guests without a password/email/etc, and\nparticipate in rooms hosted on this server which have been made\naccessible to anonymous users.\n",
                    position: (633, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (629, 37),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "account_threepid_delegates",
               position: (638, 7),
              },
              Raw {
               content: "email",
               position: (638, 34),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (638, 42),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (639, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (639, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (639, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (639, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (639, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (640, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (640, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (641, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Delegate email sending to https://example.org\n",
                    position: (642, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (638, 51),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "account_threepid_delegates",
               position: (645, 7),
              },
              Raw {
               content: "msisdn",
               position: (645, 34),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (645, 43),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (646, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (646, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (646, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (646, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (646, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (647, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (647, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (648, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Delegate SMS sending to this local process (https://localhost:8090)\n",
                    position: (649, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (645, 52),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "room_prejoin_state",
               position: (652, 7),
              },
              Raw {
               content: "additional_event_types",
               position: (652, 26),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (652, 51),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (653, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (653, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (654, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (654, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (654, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (654, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (654, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (655, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Additional events to share with users who received an invite.\n",
                    position: (656, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (652, 60),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "room_prejoin_state",
               position: (659, 7),
              },
              Raw {
               content: "disable_default_event_types",
               position: (659, 26),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (659, 56),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (660, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (660, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (661, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (661, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (661, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (662, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to disable the default state-event types for users invited to a room.\nThese are:\n\n<itemizedlist>\n<listitem><para>m.room.join_rules</para></listitem>\n<listitem><para>m.room.canonical_alias</para></listitem>\n<listitem><para>m.room.avatar</para></listitem>\n<listitem><para>m.room.encryption</para></listitem>\n<listitem><para>m.room.name</para></listitem>\n<listitem><para>m.room.create</para></listitem>\n</itemizedlist>\n",
                    position: (663, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (659, 65),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "macaroon_secret_key",
               position: (676, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (676, 29),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (677, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (677, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (677, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (677, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (677, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (678, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (678, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (679, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Secret key for authentication tokens\n",
                    position: (680, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (676, 38),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "expire_access_token",
               position: (683, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (683, 29),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (684, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (684, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (684, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (685, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (685, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (686, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to enable access token expiration.\n",
                    position: (687, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (683, 38),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "key_refresh_interval",
               position: (690, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (690, 30),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (691, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (691, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (691, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (692, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "1d",
                    position: (692, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (693, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "How long key response published by this server is valid for.\nUsed to set the valid_until_ts in /key/v2 APIs.\nDetermines how quickly servers will query to check which keys\nare still valid.\n",
                    position: (694, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (690, 39),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "app_service_config_files",
               position: (700, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (700, 34),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (701, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (701, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (701, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (701, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "path",
                       position: (701, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (702, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (702, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (703, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "A list of application service config file to use\n",
                    position: (704, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (700, 43),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "redaction_retention_period",
               position: (707, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (707, 36),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (708, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (708, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (708, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (709, 9),
                   },
                  ],
                 },
                 Int {
                  value: 7,
                  position: (709, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (710, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "How long to keep redacted events in unredacted form in the database.\n",
                    position: (711, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (707, 45),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraConfig",
               position: (714, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (714, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (715, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (715, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (715, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (716, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (717, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Extra config options for matrix-synapse.\n",
                    position: (718, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (714, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraConfigFiles",
               position: (721, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (721, 26),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (722, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (722, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (722, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (722, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "path",
                       position: (722, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (723, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (723, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (724, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Extra config files to include.\n\nThe configuration files will be included based on the command line\nargument --config-path. This allows to configure secrets without\nhaving to go through the Nix store, e.g. based on deployment keys if\nNixOPS is in use.\n",
                    position: (725, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (721, 35),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "logConfig",
               position: (733, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (733, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (734, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (734, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (734, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (735, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "readFile",
                   position: (735, 19),
                  },
                  arguments: [
                   Path {
                    parts: [
                     Raw {
                      content: "./matrix-synapse-log_config.yaml",
                      position: (735, 28),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (736, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "A yaml python logging config file\n",
                    position: (737, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (733, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "dataDir",
               position: (740, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (740, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (741, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (741, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (741, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (742, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/var/lib/matrix-synapse",
                    position: (742, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (743, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The directory where matrix-synapse stores its stateful data such as\ncertificates, media and uploads.\n",
                    position: (744, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (740, 26),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (148, 31),
         },
        ),
       ],
       recursive: false,
       position: (147, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (751, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (751, 12),
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (751, 17),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (751, 21),
           },
          ],
         },
         default: None,
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "assertions",
              position: (752, 5),
             },
            ],
           },
           List {
            elements: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (753, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Implication,
                 operands: [
                  Variable {
                   identifier: "hasLocalPostgresDB",
                   position: (753, 21),
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (753, 43),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "services",
                      position: (753, 50),
                     },
                     Raw {
                      content: "postgresql",
                      position: (753, 59),
                     },
                     Raw {
                      content: "enable",
                      position: (753, 70),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (753, 40),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (754, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Cannot deploy matrix-synapse with a configuration for a local postgresql database\n  and a missing postgresql service. Since 20.03 it's mandatory to manually configure the\n  database (please read the thread in https://github.com/NixOS/nixpkgs/pull/80447 for\n  further reference).\n\n  If you\n  - try to deploy a fresh synapse, you need to configure the database yourself. An example\n    for this can be found in <nixpkgs/nixos/tests/matrix-synapse.nix>\n  - update your existing matrix-synapse instance, you simply need to add `services.postgresql.enable = true`\n    to your configuration.\n\nFor further information about this update, please read the release-notes of 20.03 carefully.\n",
                   position: (755, 1),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (753, 7),
             },
            ],
            position: (752, 18),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (771, 5),
             },
             Raw {
              content: "matrix-synapse",
              position: (771, 14),
             },
             Raw {
              content: "configFile",
              position: (771, 29),
             },
            ],
           },
           String {
            parts: [
             Expression {
              expression: Variable {
               identifier: "configFile",
               position: (771, 45),
              },
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (773, 5),
             },
             Raw {
              content: "users",
              position: (773, 11),
             },
             Raw {
              content: "matrix-synapse",
              position: (773, 17),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "group",
                 position: (774, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "matrix-synapse",
                 position: (774, 16),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "home",
                 position: (775, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (775, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "dataDir",
                  position: (775, 18),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "createHome",
                 position: (776, 7),
                },
               ],
              },
              Variable {
               identifier: "true",
               position: (776, 20),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "shell",
                 position: (777, 7),
                },
               ],
              },
              String {
               parts: [
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (777, 18),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bash",
                     position: (777, 23),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "/bin/bash",
                 position: (777, 28),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "uid",
                 position: (778, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (778, 13),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "ids",
                  position: (778, 20),
                 },
                 Raw {
                  content: "uids",
                  position: (778, 24),
                 },
                 Raw {
                  content: "matrix-synapse",
                  position: (778, 29),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (773, 34),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (781, 5),
             },
             Raw {
              content: "groups",
              position: (781, 11),
             },
             Raw {
              content: "matrix-synapse",
              position: (781, 18),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "gid",
                 position: (782, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (782, 13),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "ids",
                  position: (782, 20),
                 },
                 Raw {
                  content: "gids",
                  position: (782, 24),
                 },
                 Raw {
                  content: "matrix-synapse",
                  position: (782, 29),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (781, 35),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (785, 5),
             },
             Raw {
              content: "services",
              position: (785, 13),
             },
             Raw {
              content: "matrix-synapse",
              position: (785, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (786, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Synapse Matrix homeserver",
                 position: (786, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "after",
                 position: (787, 7),
                },
               ],
              },
              BinaryOperation {
               operator: Concatenation,
               operands: [
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "network.target",
                     position: (787, 18),
                    },
                   ],
                  },
                 ],
                 position: (787, 15),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "optional",
                  position: (787, 39),
                 },
                 arguments: [
                  Variable {
                   identifier: "hasLocalPostgresDB",
                   position: (787, 48),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "postgresql.service",
                     position: (787, 68),
                    },
                   ],
                  },
                 ],
                },
               ],
               position: (787, 36),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wantedBy",
                 position: (788, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "multi-user.target",
                   position: (788, 21),
                  },
                 ],
                },
               ],
               position: (788, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "preStart",
                 position: (789, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "",
                 position: (790, 1),
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (790, 11),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (790, 15),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "/bin/synapse_homeserver \\\n  --config-path ",
                 position: (790, 23),
                },
                Expression {
                 expression: Variable {
                  identifier: "configFile",
                  position: (791, 27),
                 },
                },
                Raw {
                 content: " \\\n  --keys-directory ",
                 position: (791, 38),
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (792, 30),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "dataDir",
                     position: (792, 34),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: " \\\n  --generate-keys\n",
                 position: (792, 42),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "environment",
                 position: (795, 7),
                },
               ],
              },
              BinaryOperation {
               operator: Update,
               operands: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "PYTHONPATH",
                      position: (796, 9),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "makeSearchPathOutput",
                     position: (796, 22),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "lib",
                        position: (796, 44),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (796, 49),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "package",
                         position: (796, 53),
                        },
                        Raw {
                         content: "python",
                         position: (796, 61),
                        },
                        Raw {
                         content: "sitePackages",
                         position: (796, 68),
                        },
                       ],
                      },
                      default: None,
                     },
                     List {
                      elements: [
                       Variable {
                        identifier: "pluginsEnv",
                        position: (796, 83),
                       },
                      ],
                      position: (796, 81),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (795, 21),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "optionalAttrs",
                  position: (797, 12),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (797, 27),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "withJemalloc",
                      position: (797, 31),
                     },
                    ],
                   },
                   default: None,
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "LD_PRELOAD",
                        position: (798, 9),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "pkgs",
                          position: (798, 25),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "jemalloc",
                            position: (798, 30),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/lib/libjemalloc.so",
                        position: (798, 39),
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (797, 45),
                  },
                 ],
                },
               ],
               position: (797, 9),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (800, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Type",
                    position: (801, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "notify",
                    position: (801, 17),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "User",
                    position: (802, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "matrix-synapse",
                    position: (802, 17),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Group",
                    position: (803, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "matrix-synapse",
                    position: (803, 18),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "WorkingDirectory",
                    position: (804, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (804, 28),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "dataDir",
                     position: (804, 32),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStartPre",
                    position: (805, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   BinaryOperation {
                    operator: Addition,
                    operands: [
                     String {
                      parts: [
                       Raw {
                        content: "+",
                        position: (805, 28),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (805, 34),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "writeShellScript",
                          position: (805, 39),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "matrix-synapse-fix-permissions",
                          position: (805, 57),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "chown matrix-synapse:matrix-synapse ",
                          position: (806, 1),
                         },
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (806, 49),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "dataDir",
                              position: (806, 53),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: "/homeserver.signing.key\nchmod 0600 ",
                          position: (806, 61),
                         },
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (807, 24),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "dataDir",
                              position: (807, 28),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: "/homeserver.signing.key\n",
                          position: (807, 36),
                         },
                        ],
                       },
                      ],
                     },
                    ],
                    position: (805, 31),
                   },
                  ],
                  position: (805, 24),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStart",
                    position: (809, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "",
                    position: (810, 1),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (810, 13),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "package",
                        position: (810, 17),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/bin/synapse_homeserver \\\n  ",
                    position: (810, 25),
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "concatMapStringsSep",
                      position: (811, 16),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "\n  ",
                         position: (811, 37),
                        },
                       ],
                      },
                      Function {
                       argument: Some(
                        "x",
                       ),
                       arguments: FunctionArguments {
                        arguments: [],
                        ellipsis: false,
                       },
                       definition: String {
                        parts: [
                         Raw {
                          content: "--config-path ",
                          position: (811, 48),
                         },
                         Expression {
                          expression: Variable {
                           identifier: "x",
                           position: (811, 64),
                          },
                         },
                         Raw {
                          content: " \\",
                          position: (811, 66),
                         },
                        ],
                       },
                       position: (811, 44),
                      },
                      BinaryOperation {
                       operator: Concatenation,
                       operands: [
                        List {
                         elements: [
                          Variable {
                           identifier: "configFile",
                           position: (811, 75),
                          },
                         ],
                         position: (811, 73),
                        },
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (811, 91),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "extraConfigFiles",
                            position: (811, 95),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                       position: (811, 88),
                      },
                     ],
                    },
                   },
                   Raw {
                    content: "\n  --keys-directory ",
                    position: (811, 114),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (812, 32),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "dataDir",
                        position: (812, 36),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\n",
                    position: (812, 44),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecReload",
                    position: (814, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "pkgs",
                      position: (814, 25),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "util-linux",
                        position: (814, 30),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/bin/kill -HUP $MAINPID",
                    position: (814, 41),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Restart",
                    position: (815, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "on-failure",
                    position: (815, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "UMask",
                    position: (816, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "0077",
                    position: (816, 18),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (800, 23),
              },
             ),
            ],
            recursive: false,
            position: (785, 39),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (820, 5),
             },
             Raw {
              content: "systemPackages",
              position: (820, 17),
             },
            ],
           },
           List {
            elements: [
             Variable {
              identifier: "registerNewMatrixUser",
              position: (820, 36),
             },
            ],
            position: (820, 34),
           },
          ),
         ],
         recursive: false,
         position: (751, 28),
        },
       ],
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "imports",
         position: (823, 3),
        },
       ],
      },
      List {
       elements: [
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (824, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (824, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
               position: (824, 42),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "trusted_third_party_id_servers",
               position: (824, 59),
              },
             ],
            },
           ],
           position: (824, 28),
          },
          String {
           parts: [
            Raw {
             content: "The `trusted_third_party_id_servers` option as been removed in `matrix-synapse` v1.4.0\nas the behavior is now obsolete.\n",
             position: (825, 1),
            },
           ],
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (828, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (828, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
               position: (828, 42),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "create_local_database",
               position: (828, 59),
              },
             ],
            },
           ],
           position: (828, 28),
          },
          String {
           parts: [
            Raw {
             content: "Database configuration must be done manually. An exemplary setup is demonstrated in\n<nixpkgs/nixos/tests/matrix-synapse.nix>\n",
             position: (829, 1),
            },
           ],
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (832, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (832, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
               position: (832, 42),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "web_client",
               position: (832, 59),
              },
             ],
            },
           ],
           position: (832, 28),
          },
          String {
           parts: [],
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (833, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (833, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
               position: (833, 42),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "room_invite_state_types",
               position: (833, 59),
              },
             ],
            },
           ],
           position: (833, 28),
          },
          String {
           parts: [
            Raw {
             content: "You may add additional event types via\n`services.matrix-synapse.room_prejoin_state.additional_event_types` and\ndisable the default events via\n`services.matrix-synapse.room_prejoin_state.disable_default_event_types`.\n",
             position: (834, 1),
            },
           ],
          },
         ],
        },
       ],
       position: (823, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "meta",
         position: (841, 3),
        },
        Raw {
         content: "doc",
         position: (841, 8),
        },
       ],
      },
      Path {
       parts: [
        Raw {
         content: "./matrix-synapse.xml",
         position: (841, 14),
        },
       ],
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "meta",
         position: (842, 3),
        },
        Raw {
         content: "maintainers",
         position: (842, 8),
        },
       ],
      },
      PropertyAccess {
       expression: Variable {
        identifier: "teams",
        position: (842, 22),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "matrix",
          position: (842, 28),
         },
         Raw {
          content: "members",
          position: (842, 35),
         },
        ],
       },
       default: None,
      },
     ),
    ],
    recursive: false,
    position: (146, 4),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}