---
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: "format",
        position: (7, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (7, 12),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "formats",
          position: (7, 17),
         },
         Raw {
          content: "yaml",
          position: (7, 25),
         },
        ],
       },
       default: None,
      },
      arguments: [
       Map {
        bindings: [],
        recursive: false,
        position: (7, 30),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "finalSettings",
        position: (10, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "lib",
        position: (10, 19),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "filterAttrsRecursive",
          position: (10, 23),
         },
        ],
       },
       default: None,
      },
      arguments: [
       Function {
        argument: Some(
         "_",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: Function {
         argument: Some(
          "v",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: BinaryOperation {
          operator: NotEqualTo,
          operands: [
           Variable {
            identifier: "v",
            position: (10, 51),
           },
           Variable {
            identifier: "null",
            position: (10, 56),
           },
          ],
          position: (10, 53),
         },
         position: (10, 48),
        },
        position: (10, 45),
       },
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (10, 62),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "settings",
           position: (10, 66),
          },
         ],
        },
        default: None,
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "configFile",
        position: (11, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "format",
        position: (11, 16),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "generate",
          position: (11, 23),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "homeserver.yaml",
         },
        ],
        position: (11, 32),
       },
       Variable {
        identifier: "finalSettings",
        position: (11, 50),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "logConfigFile",
        position: (12, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "format",
        position: (12, 19),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "generate",
          position: (12, 26),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "log_config.yaml",
         },
        ],
        position: (12, 35),
       },
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (12, 53),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "logConfig",
           position: (12, 57),
          },
         ],
        },
        default: None,
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "pluginsEnv",
        position: (14, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "cfg",
        position: (14, 16),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "package",
          position: (14, 20),
         },
         Raw {
          content: "python",
          position: (14, 28),
         },
         Raw {
          content: "buildEnv",
          position: (14, 35),
         },
         Raw {
          content: "override",
          position: (14, 44),
         },
        ],
       },
       default: None,
      },
      arguments: [
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "extraLibs",
             position: (15, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (15, 17),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "plugins",
              position: (15, 21),
             },
            ],
           },
           default: None,
          },
         ),
        ],
        recursive: false,
        position: (14, 53),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "usePostgresql",
        position: (18, 3),
       },
      ],
     },
     BinaryOperation {
      operator: EqualTo,
      operands: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (18, 19),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "settings",
           position: (18, 23),
          },
          Raw {
           content: "database",
           position: (18, 32),
          },
          Raw {
           content: "name",
           position: (18, 41),
          },
         ],
        },
        default: None,
       },
       String {
        parts: [
         Raw {
          content: "psycopg2",
         },
        ],
        position: (18, 49),
       },
      ],
      position: (18, 46),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "hasLocalPostgresDB",
        position: (19, 3),
       },
      ],
     },
     LetIn {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "args",
           position: (19, 28),
          },
         ],
        },
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (19, 35),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "settings",
            position: (19, 39),
           },
           Raw {
            content: "database",
            position: (19, 48),
           },
           Raw {
            content: "args",
            position: (19, 57),
           },
          ],
         },
         default: None,
        },
       ),
      ],
      target: BinaryOperation {
       operator: LogicalAnd,
       operands: [
        Variable {
         identifier: "usePostgresql",
         position: (20, 5),
        },
        BinaryOperation {
         operator: LogicalOr,
         operands: [
          UnaryOperation {
           operator: Not,
           operand: HasProperty {
            expression: Variable {
             identifier: "args",
             position: (20, 25),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "host",
               position: (20, 32),
              },
             ],
            },
            position: (20, 30),
           },
           position: (20, 23),
          },
          FunctionApplication {
           function: Variable {
            identifier: "elem",
            position: (20, 42),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "args",
              position: (20, 47),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "host",
                position: (20, 52),
               },
              ],
             },
             default: None,
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "localhost",
                },
               ],
               position: (20, 59),
              },
              String {
               parts: [
                Raw {
                 content: "127.0.0.1",
                },
               ],
               position: (20, 71),
              },
              String {
               parts: [
                Raw {
                 content: "::1",
                },
               ],
               position: (20, 83),
              },
             ],
             position: (20, 57),
            },
           ],
          },
         ],
         position: (20, 38),
        },
       ],
       position: (20, 19),
      },
      position: (19, 24),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "registerNewMatrixUser",
        position: (22, 3),
       },
      ],
     },
     LetIn {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "isIpv6",
           position: (24, 7),
          },
         ],
        },
        Function {
         argument: Some(
          "x",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: BinaryOperation {
          operator: GreaterThan,
          operands: [
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "lib",
              position: (24, 19),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "length",
                position: (24, 23),
               },
              ],
             },
             default: None,
            },
            arguments: [
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "lib",
                position: (24, 31),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "splitString",
                  position: (24, 35),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: ":",
                 },
                ],
                position: (24, 47),
               },
               Variable {
                identifier: "x",
                position: (24, 51),
               },
              ],
             },
            ],
           },
           Int {
            value: 1,
            position: (24, 56),
           },
          ],
          position: (24, 54),
         },
         position: (24, 16),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "listener",
           position: (25, 7),
          },
         ],
        },
        FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "lib",
           position: (26, 9),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "findFirst",
             position: (26, 13),
            },
           ],
          },
          default: None,
         },
         arguments: [
          Function {
           argument: Some(
            "listener",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "lib",
              position: (27, 21),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "any",
                position: (27, 25),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Function {
              argument: Some(
               "resource",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (28, 23),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "any",
                   position: (28, 27),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Function {
                 argument: Some(
                  "name",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   Variable {
                    identifier: "name",
                    position: (29, 21),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "client",
                     },
                    ],
                    position: (29, 29),
                   },
                  ],
                  position: (29, 26),
                 },
                 position: (29, 15),
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "resource",
                  position: (30, 15),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "names",
                    position: (30, 24),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
              position: (28, 13),
             },
             PropertyAccess {
              expression: Variable {
               identifier: "listener",
               position: (31, 13),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "resources",
                 position: (31, 22),
                },
               ],
              },
              default: None,
             },
            ],
           },
           position: (27, 11),
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (32, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "last",
               position: (32, 16),
              },
             ],
            },
            default: None,
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (32, 21),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "settings",
                position: (32, 25),
               },
               Raw {
                content: "listeners",
                position: (32, 34),
               },
              ],
             },
             default: None,
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (32, 45),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "settings",
              position: (32, 49),
             },
             Raw {
              content: "listeners",
              position: (32, 58),
             },
            ],
           },
           default: None,
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "bindAddress",
           position: (37, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "head",
          position: (37, 21),
         },
         arguments: [
          BinaryOperation {
           operator: Concatenation,
           operands: [
            PropertyAccess {
             expression: Variable {
              identifier: "listener",
              position: (37, 27),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "bind_addresses",
                position: (37, 36),
               },
              ],
             },
             default: None,
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "127.0.0.1",
                },
               ],
               position: (37, 56),
              },
             ],
             position: (37, 54),
            },
           ],
           position: (37, 51),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "listenerProtocol",
           position: (38, 7),
          },
         ],
        },
        IfThenElse {
         predicate: PropertyAccess {
          expression: Variable {
           identifier: "listener",
           position: (38, 29),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "tls",
             position: (38, 38),
            },
           ],
          },
          default: None,
         },
         then: String {
          parts: [
           Raw {
            content: "https",
           },
          ],
          position: (39, 14),
         },
         else_: String {
          parts: [
           Raw {
            content: "http",
           },
          ],
          position: (40, 14),
         },
         position: (38, 26),
        },
       ),
      ],
      target: FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "pkgs",
         position: (42, 5),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "writeShellScriptBin",
           position: (42, 10),
          },
         ],
        },
        default: None,
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "matrix-synapse-register_new_matrix_user",
          },
         ],
         position: (42, 30),
        },
        String {
         parts: [
          Raw {
           content: "exec ",
          },
          Expression {
           expression: PropertyAccess {
            expression: Variable {
             identifier: "cfg",
             position: (43, 14),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "package",
               position: (43, 18),
              },
             ],
            },
            default: None,
           },
          },
          Raw {
           content: "/bin/register_new_matrix_user \\\n  $@ \\\n  ",
          },
          Expression {
           expression: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "lib",
              position: (45, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "concatMapStringsSep",
                position: (45, 15),
               },
              ],
             },
             default: None,
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: " ",
               },
              ],
              position: (45, 35),
             },
             Function {
              argument: Some(
               "x",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: String {
               parts: [
                Raw {
                 content: "-c ",
                },
                Expression {
                 expression: Variable {
                  identifier: "x",
                  position: (45, 49),
                 },
                },
               ],
               position: (45, 43),
              },
              position: (45, 40),
             },
             BinaryOperation {
              operator: Concatenation,
              operands: [
               List {
                elements: [
                 Variable {
                  identifier: "configFile",
                  position: (45, 57),
                 },
                ],
                position: (45, 55),
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (45, 73),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "extraConfigFiles",
                   position: (45, 77),
                  },
                 ],
                },
                default: None,
               },
              ],
              position: (45, 70),
             },
            ],
           },
          },
          Raw {
           content: " \\\n  \"",
          },
          Expression {
           expression: Variable {
            identifier: "listenerProtocol",
            position: (46, 12),
           },
          },
          Raw {
           content: "://",
          },
          Expression {
           expression: IfThenElse {
            predicate: FunctionApplication {
             function: Variable {
              identifier: "isIpv6",
              position: (47, 15),
             },
             arguments: [
              Variable {
               identifier: "bindAddress",
               position: (47, 22),
              },
             ],
            },
            then: String {
             parts: [
              Raw {
               content: "[",
              },
              Expression {
               expression: Variable {
                identifier: "bindAddress",
                position: (48, 17),
               },
              },
              Raw {
               content: "]",
              },
             ],
             position: (48, 13),
            },
            else_: String {
             parts: [
              Expression {
               expression: Variable {
                identifier: "bindAddress",
                position: (50, 16),
               },
              },
             ],
             position: (50, 13),
            },
            position: (47, 11),
           },
          },
          Raw {
           content: ":",
          },
          Expression {
           expression: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (51, 13),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "toString",
                position: (51, 22),
               },
              ],
             },
             default: None,
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "listener",
               position: (51, 31),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "port",
                 position: (51, 40),
                },
               ],
              },
              default: None,
             },
            ],
           },
          },
          Raw {
           content: "/\"\n",
          },
         ],
         position: (42, 72),
        },
       ],
      },
      position: (23, 5),
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "imports",
         position: (55, 3),
        },
       ],
      },
      List {
       elements: [
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (57, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (57, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (57, 41),
            },
            String {
             parts: [
              Raw {
               content: "trusted_third_party_id_servers",
              },
             ],
             position: (57, 58),
            },
           ],
           position: (57, 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: (57, 93),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (61, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (61, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (61, 41),
            },
            String {
             parts: [
              Raw {
               content: "create_local_database",
              },
             ],
             position: (61, 58),
            },
           ],
           position: (61, 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: (61, 84),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (65, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (65, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (65, 41),
            },
            String {
             parts: [
              Raw {
               content: "web_client",
              },
             ],
             position: (65, 58),
            },
           ],
           position: (65, 28),
          },
          String {
           parts: [],
           position: (65, 73),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (66, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (66, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (66, 41),
            },
            String {
             parts: [
              Raw {
               content: "room_invite_state_types",
              },
             ],
             position: (66, 58),
            },
           ],
           position: (66, 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: (66, 86),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (74, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (74, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (74, 41),
            },
            String {
             parts: [
              Raw {
               content: "bind_host",
              },
             ],
             position: (74, 58),
            },
           ],
           position: (74, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use listener settings instead.",
            },
           ],
           position: (74, 72),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (75, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (75, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (75, 41),
            },
            String {
             parts: [
              Raw {
               content: "bind_port",
              },
             ],
             position: (75, 58),
            },
           ],
           position: (75, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use listener settings instead.",
            },
           ],
           position: (75, 72),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (76, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (76, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (76, 41),
            },
            String {
             parts: [
              Raw {
               content: "expire_access_tokens",
              },
             ],
             position: (76, 58),
            },
           ],
           position: (76, 28),
          },
          String {
           parts: [],
           position: (76, 83),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (77, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (77, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (77, 41),
            },
            String {
             parts: [
              Raw {
               content: "no_tls",
              },
             ],
             position: (77, 58),
            },
           ],
           position: (77, 28),
          },
          String {
           parts: [
            Raw {
             content: "It is no longer supported by synapse.",
            },
           ],
           position: (77, 69),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (78, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (78, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (78, 41),
            },
            String {
             parts: [
              Raw {
               content: "tls_dh_param_path",
              },
             ],
             position: (78, 58),
            },
           ],
           position: (78, 28),
          },
          String {
           parts: [
            Raw {
             content: "It was removed from synapse.",
            },
           ],
           position: (78, 80),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (79, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (79, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (79, 41),
            },
            String {
             parts: [
              Raw {
               content: "unsecure_port",
              },
             ],
             position: (79, 58),
            },
           ],
           position: (79, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.listeners instead.",
            },
           ],
           position: (79, 76),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (80, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (80, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (80, 41),
            },
            String {
             parts: [
              Raw {
               content: "user_creation_max_duration",
              },
             ],
             position: (80, 58),
            },
           ],
           position: (80, 28),
          },
          String {
           parts: [
            Raw {
             content: "It is no longer supported by synapse.",
            },
           ],
           position: (80, 89),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (81, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (81, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (81, 41),
            },
            String {
             parts: [
              Raw {
               content: "verbose",
              },
             ],
             position: (81, 58),
            },
           ],
           position: (81, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use a log config instead.",
            },
           ],
           position: (81, 70),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (84, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (84, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (84, 41),
            },
            String {
             parts: [
              Raw {
               content: "app_service_config_files",
              },
             ],
             position: (84, 58),
            },
           ],
           position: (84, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.app_service_config_Files instead",
            },
           ],
           position: (84, 87),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (85, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (85, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (85, 41),
            },
            String {
             parts: [
              Raw {
               content: "database_args",
              },
             ],
             position: (85, 58),
            },
           ],
           position: (85, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.database.args instead",
            },
           ],
           position: (85, 76),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (86, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (86, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (86, 41),
            },
            String {
             parts: [
              Raw {
               content: "database_name",
              },
             ],
             position: (86, 58),
            },
           ],
           position: (86, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.database.args.database instead",
            },
           ],
           position: (86, 76),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (87, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (87, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (87, 41),
            },
            String {
             parts: [
              Raw {
               content: "database_type",
              },
             ],
             position: (87, 58),
            },
           ],
           position: (87, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.database.name instead",
            },
           ],
           position: (87, 76),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (88, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (88, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (88, 41),
            },
            String {
             parts: [
              Raw {
               content: "database_user",
              },
             ],
             position: (88, 58),
            },
           ],
           position: (88, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.database.args.user instead",
            },
           ],
           position: (88, 76),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (89, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (89, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (89, 41),
            },
            String {
             parts: [
              Raw {
               content: "dynamic_thumbnails",
              },
             ],
             position: (89, 58),
            },
           ],
           position: (89, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.dynamic_thumbnails instead",
            },
           ],
           position: (89, 81),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (90, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (90, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (90, 41),
            },
            String {
             parts: [
              Raw {
               content: "enable_metrics",
              },
             ],
             position: (90, 58),
            },
           ],
           position: (90, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.enable_metrics instead",
            },
           ],
           position: (90, 77),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (91, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (91, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (91, 41),
            },
            String {
             parts: [
              Raw {
               content: "enable_registration",
              },
             ],
             position: (91, 58),
            },
           ],
           position: (91, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.enable_registration instead",
            },
           ],
           position: (91, 82),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (92, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (92, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (92, 41),
            },
            String {
             parts: [
              Raw {
               content: "extraConfig",
              },
             ],
             position: (92, 58),
            },
           ],
           position: (92, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings instead.",
            },
           ],
           position: (92, 74),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (93, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (93, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (93, 41),
            },
            String {
             parts: [
              Raw {
               content: "listeners",
              },
             ],
             position: (93, 58),
            },
           ],
           position: (93, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.listeners instead",
            },
           ],
           position: (93, 72),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (94, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (94, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (94, 41),
            },
            String {
             parts: [
              Raw {
               content: "logConfig",
              },
             ],
             position: (94, 58),
            },
           ],
           position: (94, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.log_config instead",
            },
           ],
           position: (94, 72),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (95, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (95, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (95, 41),
            },
            String {
             parts: [
              Raw {
               content: "max_image_pixels",
              },
             ],
             position: (95, 58),
            },
           ],
           position: (95, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.max_image_pixels instead",
            },
           ],
           position: (95, 79),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (96, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (96, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (96, 41),
            },
            String {
             parts: [
              Raw {
               content: "max_upload_size",
              },
             ],
             position: (96, 58),
            },
           ],
           position: (96, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.max_upload_size instead",
            },
           ],
           position: (96, 78),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (97, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (97, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (97, 41),
            },
            String {
             parts: [
              Raw {
               content: "presence",
              },
             ],
             position: (97, 58),
            },
            String {
             parts: [
              Raw {
               content: "enabled",
              },
             ],
             position: (97, 69),
            },
           ],
           position: (97, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.presence.enabled instead",
            },
           ],
           position: (97, 81),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (98, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (98, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (98, 41),
            },
            String {
             parts: [
              Raw {
               content: "public_baseurl",
              },
             ],
             position: (98, 58),
            },
           ],
           position: (98, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.public_baseurl instead",
            },
           ],
           position: (98, 77),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (99, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (99, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (99, 41),
            },
            String {
             parts: [
              Raw {
               content: "report_stats",
              },
             ],
             position: (99, 58),
            },
           ],
           position: (99, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.report_stats instead",
            },
           ],
           position: (99, 75),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (100, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (100, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (100, 41),
            },
            String {
             parts: [
              Raw {
               content: "server_name",
              },
             ],
             position: (100, 58),
            },
           ],
           position: (100, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.server_name instead",
            },
           ],
           position: (100, 74),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (101, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (101, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (101, 41),
            },
            String {
             parts: [
              Raw {
               content: "servers",
              },
             ],
             position: (101, 58),
            },
           ],
           position: (101, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.trusted_key_servers instead.",
            },
           ],
           position: (101, 70),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (102, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (102, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (102, 41),
            },
            String {
             parts: [
              Raw {
               content: "tls_certificate_path",
              },
             ],
             position: (102, 58),
            },
           ],
           position: (102, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.tls_certificate_path instead",
            },
           ],
           position: (102, 83),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (103, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (103, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (103, 41),
            },
            String {
             parts: [
              Raw {
               content: "tls_private_key_path",
              },
             ],
             position: (103, 58),
            },
           ],
           position: (103, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.tls_private_key_path instead",
            },
           ],
           position: (103, 83),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (104, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (104, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (104, 41),
            },
            String {
             parts: [
              Raw {
               content: "turn_shared_secret",
              },
             ],
             position: (104, 58),
            },
           ],
           position: (104, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.turn_shared_secret instead",
            },
           ],
           position: (104, 81),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (105, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (105, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (105, 41),
            },
            String {
             parts: [
              Raw {
               content: "turn_uris",
              },
             ],
             position: (105, 58),
            },
           ],
           position: (105, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.turn_uris instead",
            },
           ],
           position: (105, 72),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (106, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (106, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (106, 41),
            },
            String {
             parts: [
              Raw {
               content: "turn_user_lifetime",
              },
             ],
             position: (106, 58),
            },
           ],
           position: (106, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.turn_user_lifetime instead",
            },
           ],
           position: (106, 81),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (107, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (107, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (107, 41),
            },
            String {
             parts: [
              Raw {
               content: "url_preview_enabled",
              },
             ],
             position: (107, 58),
            },
           ],
           position: (107, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.url_preview_enabled instead",
            },
           ],
           position: (107, 82),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (108, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (108, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (108, 41),
            },
            String {
             parts: [
              Raw {
               content: "url_preview_ip_range_blacklist",
              },
             ],
             position: (108, 58),
            },
           ],
           position: (108, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.url_preview_ip_range_blacklist instead",
            },
           ],
           position: (108, 93),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (109, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (109, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (109, 41),
            },
            String {
             parts: [
              Raw {
               content: "url_preview_ip_range_whitelist",
              },
             ],
             position: (109, 58),
            },
           ],
           position: (109, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.url_preview_ip_range_whitelist instead",
            },
           ],
           position: (109, 93),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (110, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (110, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (110, 41),
            },
            String {
             parts: [
              Raw {
               content: "url_preview_url_blacklist",
              },
             ],
             position: (110, 58),
            },
           ],
           position: (110, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.url_preview_url_blacklist instead",
            },
           ],
           position: (110, 88),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (113, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (113, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (113, 41),
            },
            String {
             parts: [
              Raw {
               content: "account_threepid_delegates",
              },
             ],
             position: (113, 58),
            },
            String {
             parts: [
              Raw {
               content: "email",
              },
             ],
             position: (113, 87),
            },
           ],
           position: (113, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.account_threepid_delegates.email instead",
            },
           ],
           position: (113, 97),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (114, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (114, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (114, 41),
            },
            String {
             parts: [
              Raw {
               content: "account_threepid_delegates",
              },
             ],
             position: (114, 58),
            },
            String {
             parts: [
              Raw {
               content: "msisdn",
              },
             ],
             position: (114, 87),
            },
           ],
           position: (114, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.account_threepid_delegates.msisdn instead",
            },
           ],
           position: (114, 98),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (115, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (115, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (115, 41),
            },
            String {
             parts: [
              Raw {
               content: "allow_guest_access",
              },
             ],
             position: (115, 58),
            },
           ],
           position: (115, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.allow_guest_access instead",
            },
           ],
           position: (115, 81),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (116, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (116, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (116, 41),
            },
            String {
             parts: [
              Raw {
               content: "bcrypt_rounds",
              },
             ],
             position: (116, 58),
            },
           ],
           position: (116, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.bcrypt_rounds instead",
            },
           ],
           position: (116, 76),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (117, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (117, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (117, 41),
            },
            String {
             parts: [
              Raw {
               content: "enable_registration_captcha",
              },
             ],
             position: (117, 58),
            },
           ],
           position: (117, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.enable_registration_captcha instead",
            },
           ],
           position: (117, 90),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (118, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (118, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (118, 41),
            },
            String {
             parts: [
              Raw {
               content: "event_cache_size",
              },
             ],
             position: (118, 58),
            },
           ],
           position: (118, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.event_cache_size instead",
            },
           ],
           position: (118, 79),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (119, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (119, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (119, 41),
            },
            String {
             parts: [
              Raw {
               content: "federation_rc_concurrent",
              },
             ],
             position: (119, 58),
            },
           ],
           position: (119, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.rc_federation.concurrent instead",
            },
           ],
           position: (119, 87),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (120, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (120, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (120, 41),
            },
            String {
             parts: [
              Raw {
               content: "federation_rc_reject_limit",
              },
             ],
             position: (120, 58),
            },
           ],
           position: (120, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.rc_federation.reject_limit instead",
            },
           ],
           position: (120, 89),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (121, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (121, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (121, 41),
            },
            String {
             parts: [
              Raw {
               content: "federation_rc_sleep_delay",
              },
             ],
             position: (121, 58),
            },
           ],
           position: (121, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.rc_federation.sleep_delay instead",
            },
           ],
           position: (121, 88),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (122, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (122, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (122, 41),
            },
            String {
             parts: [
              Raw {
               content: "federation_rc_sleep_limit",
              },
             ],
             position: (122, 58),
            },
           ],
           position: (122, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.rc_federation.sleep_limit instead",
            },
           ],
           position: (122, 88),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (123, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (123, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (123, 41),
            },
            String {
             parts: [
              Raw {
               content: "federation_rc_window_size",
              },
             ],
             position: (123, 58),
            },
           ],
           position: (123, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.rc_federation.window_size instead",
            },
           ],
           position: (123, 88),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (124, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (124, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (124, 41),
            },
            String {
             parts: [
              Raw {
               content: "key_refresh_interval",
              },
             ],
             position: (124, 58),
            },
           ],
           position: (124, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.key_refresh_interval instead",
            },
           ],
           position: (124, 83),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (125, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (125, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (125, 41),
            },
            String {
             parts: [
              Raw {
               content: "rc_messages_burst_count",
              },
             ],
             position: (125, 58),
            },
           ],
           position: (125, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.rc_messages.burst_count instead",
            },
           ],
           position: (125, 86),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (126, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (126, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (126, 41),
            },
            String {
             parts: [
              Raw {
               content: "rc_messages_per_second",
              },
             ],
             position: (126, 58),
            },
           ],
           position: (126, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.rc_messages.per_second instead",
            },
           ],
           position: (126, 85),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (127, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (127, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (127, 41),
            },
            String {
             parts: [
              Raw {
               content: "recaptcha_private_key",
              },
             ],
             position: (127, 58),
            },
           ],
           position: (127, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.recaptcha_private_key instead",
            },
           ],
           position: (127, 84),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (128, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (128, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (128, 41),
            },
            String {
             parts: [
              Raw {
               content: "recaptcha_public_key",
              },
             ],
             position: (128, 58),
            },
           ],
           position: (128, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.recaptcha_public_key instead",
            },
           ],
           position: (128, 83),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (129, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (129, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (129, 41),
            },
            String {
             parts: [
              Raw {
               content: "redaction_retention_period",
              },
             ],
             position: (129, 58),
            },
           ],
           position: (129, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.redaction_retention_period instead",
            },
           ],
           position: (129, 89),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (130, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (130, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (130, 41),
            },
            String {
             parts: [
              Raw {
               content: "room_prejoin_state",
              },
             ],
             position: (130, 58),
            },
            String {
             parts: [
              Raw {
               content: "additional_event_types",
              },
             ],
             position: (130, 79),
            },
           ],
           position: (130, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.room_prejoin_state.additional_event_types instead",
            },
           ],
           position: (130, 106),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (131, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (131, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (131, 41),
            },
            String {
             parts: [
              Raw {
               content: "room_prejoin_state",
              },
             ],
             position: (131, 58),
            },
            String {
             parts: [
              Raw {
               content: "disable_default_event_types",
              },
             ],
             position: (131, 79),
            },
           ],
           position: (131, 28),
          },
          String {
           parts: [
            Raw {
             content: "Use settings.room_prejoin-state.disable_default_event_types instead",
            },
           ],
           position: (131, 111),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (134, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (134, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (134, 41),
            },
            String {
             parts: [
              Raw {
               content: "macaroon_secret_key",
              },
             ],
             position: (134, 58),
            },
           ],
           position: (134, 28),
          },
          String {
           parts: [
            Raw {
             content: "Pass this value via extraConfigFiles instead",
            },
           ],
           position: (134, 82),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (135, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (135, 30),
            },
            String {
             parts: [
              Raw {
               content: "matrix-synapse",
              },
             ],
             position: (135, 41),
            },
            String {
             parts: [
              Raw {
               content: "registration_shared_secret",
              },
             ],
             position: (135, 58),
            },
           ],
           position: (135, 28),
          },
          String {
           parts: [
            Raw {
             content: "Pass this value via extraConfigFiles instead",
            },
           ],
           position: (135, 89),
          },
         ],
        },
       ],
       position: (55, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (139, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "services",
            position: (140, 5),
           },
           Raw {
            content: "matrix-synapse",
            position: (140, 14),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (141, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkEnableOption",
              position: (141, 16),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "matrix.org synapse",
                },
               ],
               position: (141, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "configFile",
               position: (143, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (143, 20),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (144, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (144, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "path",
                     position: (144, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "readOnly",
                    position: (145, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (145, 20),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (146, 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: (146, 23),
                 },
                ),
               ],
               recursive: false,
               position: (143, 29),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "package",
               position: (152, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (152, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (153, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (153, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (153, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (154, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (154, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "matrix-synapse",
                     position: (154, 24),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (155, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (155, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.matrix-synapse",
                     },
                    ],
                    position: (155, 41),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (156, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Overridable attribute of the matrix synapse server package to use.\n",
                   },
                  ],
                  position: (156, 23),
                 },
                ),
               ],
               recursive: false,
               position: (152, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "plugins",
               position: (161, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (161, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (162, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (162, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (162, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (162, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "package",
                       position: (162, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (163, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (163, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (164, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (164, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "with config.services.matrix-synapse.package.plugins; [\n  matrix-synapse-ldap3\n  matrix-synapse-pam\n];\n",
                     },
                    ],
                    position: (164, 37),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (170, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "List of additional Matrix plugins to make available.\n",
                   },
                  ],
                  position: (170, 23),
                 },
                ),
               ],
               recursive: false,
               position: (161, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "withJemalloc",
               position: (175, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (175, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (176, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (176, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (176, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (177, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (177, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (178, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to preload jemalloc to reduce memory fragmentation and overall usage.\n",
                   },
                  ],
                  position: (178, 23),
                 },
                ),
               ],
               recursive: false,
               position: (175, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "dataDir",
               position: (183, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (183, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (184, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (184, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (184, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (185, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/var/lib/matrix-synapse",
                   },
                  ],
                  position: (185, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (186, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The directory where matrix-synapse stores its stateful data such as\ncertificates, media and uploads.\n",
                   },
                  ],
                  position: (186, 23),
                 },
                ),
               ],
               recursive: false,
               position: (183, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "settings",
               position: (192, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (192, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (193, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (193, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (194, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The primary synapse configuration. See the\n<link xlink:href=\"https://github.com/matrix-org/synapse/blob/v",
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (196, 75),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "package",
                        position: (196, 79),
                       },
                       Raw {
                        content: "version",
                        position: (196, 87),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/docs/sample_config.yaml\">sample configuration</link>\nfor possible values.\n\nSecrets should be passed in by using the <literal>extraConfigFiles</literal> option.\n",
                   },
                  ],
                  position: (194, 23),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (201, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (201, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "submodule",
                    position: (201, 28),
                   },
                   arguments: [
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "freeformType",
                          position: (202, 11),
                         },
                        ],
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "format",
                         position: (202, 26),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "type",
                           position: (202, 33),
                          },
                         ],
                        },
                        default: None,
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "options",
                          position: (203, 11),
                         },
                        ],
                       },
                       Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "server_name",
                             position: (208, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (208, 27),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (209, 15),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (209, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "str",
                                   position: (209, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "example",
                                  position: (210, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "example.com",
                                 },
                                ],
                                position: (210, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (211, 15),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "config",
                                 position: (211, 25),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "networking",
                                   position: (211, 32),
                                  },
                                  Raw {
                                   content: "hostName",
                                   position: (211, 43),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "defaultText",
                                  position: (212, 15),
                                 },
                                ],
                               },
                               FunctionApplication {
                                function: Variable {
                                 identifier: "literalExpression",
                                 position: (212, 29),
                                },
                                arguments: [
                                 String {
                                  parts: [
                                   Raw {
                                    content: "config.networking.hostName",
                                   },
                                  ],
                                  position: (212, 47),
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (213, 15),
                                 },
                                ],
                               },
                               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: (213, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (208, 36),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "enable_registration",
                             position: (222, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (222, 35),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (223, 15),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (223, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "bool",
                                   position: (223, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (224, 15),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "false",
                                position: (224, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (225, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "Enable registration for new users.\n",
                                 },
                                ],
                                position: (225, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (222, 44),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "registration_shared_secret",
                             position: (230, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (230, 42),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (231, 15),
                                 },
                                ],
                               },
                               FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (231, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "nullOr",
                                    position: (231, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (231, 35),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "str",
                                     position: (231, 41),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (232, 15),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "null",
                                position: (232, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (233, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "If set, allows registration by anyone who also has the shared\nsecret, even if registration is otherwise disabled.\n\nSecrets should be passed in via <literal>extraConfigFiles</literal>!\n",
                                 },
                                ],
                                position: (233, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (230, 51),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "macaroon_secret_key",
                             position: (241, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (241, 35),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (242, 15),
                                 },
                                ],
                               },
                               FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (242, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "nullOr",
                                    position: (242, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (242, 35),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "str",
                                     position: (242, 41),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (243, 15),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "null",
                                position: (243, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (244, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "Secret key for authentication tokens. If none is specified,\nthe registration_shared_secret is used, if one is given; otherwise,\na secret key is derived from the signing key.\n\nSecrets should be passed in via <literal>extraConfigFiles</literal>!\n",
                                 },
                                ],
                                position: (244, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (241, 44),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "enable_metrics",
                             position: (253, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (253, 30),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (254, 15),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (254, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "bool",
                                   position: (254, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (255, 15),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "false",
                                position: (255, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (256, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "Enable collection and rendering of performance metrics\n",
                                 },
                                ],
                                position: (256, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (253, 39),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "report_stats",
                             position: (261, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (261, 28),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (262, 15),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (262, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "bool",
                                   position: (262, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (263, 15),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "false",
                                position: (263, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (264, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "Whether or not to report anonymized homeserver usage statistics.\n",
                                 },
                                ],
                                position: (264, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (261, 37),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "signing_key_path",
                             position: (269, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (269, 32),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (270, 15),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (270, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "path",
                                   position: (270, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (271, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Expression {
                                  expression: PropertyAccess {
                                   expression: Variable {
                                    identifier: "cfg",
                                    position: (271, 28),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "dataDir",
                                      position: (271, 32),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                 },
                                 Raw {
                                  content: "/homeserver.signing.key",
                                 },
                                ],
                                position: (271, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (272, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "Path to the signing key to sign messages with.\n",
                                 },
                                ],
                                position: (272, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (269, 41),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "pid_file",
                             position: (277, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (277, 24),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (278, 15),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (278, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "path",
                                   position: (278, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (279, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "/run/matrix-synapse.pid",
                                 },
                                ],
                                position: (279, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "readOnly",
                                  position: (280, 15),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "true",
                                position: (280, 26),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (281, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "The file to store the PID in.\n",
                                 },
                                ],
                                position: (281, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (277, 33),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "log_config",
                             position: (286, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (286, 26),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (287, 15),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (287, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "path",
                                   position: (287, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (288, 15),
                                 },
                                ],
                               },
                               Path {
                                parts: [
                                 Raw {
                                  content: "./matrix-synapse-log_config.yaml",
                                 },
                                ],
                                position: (288, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (289, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "The file that holds the logging configuration.\n",
                                 },
                                ],
                                position: (289, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (286, 35),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "media_store_path",
                             position: (294, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (294, 32),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (295, 15),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (295, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "path",
                                   position: (295, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (296, 15),
                                 },
                                ],
                               },
                               IfThenElse {
                                predicate: FunctionApplication {
                                 function: PropertyAccess {
                                  expression: Variable {
                                   identifier: "lib",
                                   position: (296, 28),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "versionAtLeast",
                                     position: (296, 32),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 arguments: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "config",
                                    position: (296, 47),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "system",
                                      position: (296, 54),
                                     },
                                     Raw {
                                      content: "stateVersion",
                                      position: (296, 61),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  String {
                                   parts: [
                                    Raw {
                                     content: "22.05",
                                    },
                                   ],
                                   position: (296, 74),
                                  },
                                 ],
                                },
                                then: String {
                                 parts: [
                                  Expression {
                                   expression: PropertyAccess {
                                    expression: Variable {
                                     identifier: "cfg",
                                     position: (297, 25),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "dataDir",
                                       position: (297, 29),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                  },
                                  Raw {
                                   content: "/media_store",
                                  },
                                 ],
                                 position: (297, 22),
                                },
                                else_: String {
                                 parts: [
                                  Expression {
                                   expression: PropertyAccess {
                                    expression: Variable {
                                     identifier: "cfg",
                                     position: (298, 25),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "dataDir",
                                       position: (298, 29),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                  },
                                  Raw {
                                   content: "/media",
                                  },
                                 ],
                                 position: (298, 22),
                                },
                                position: (296, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (299, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "Directory where uploaded images and attachments are stored.\n",
                                 },
                                ],
                                position: (299, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (294, 41),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "public_baseurl",
                             position: (304, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (304, 30),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (305, 15),
                                 },
                                ],
                               },
                               FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (305, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "nullOr",
                                    position: (305, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (305, 35),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "str",
                                     position: (305, 41),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (306, 15),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "null",
                                position: (306, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "example",
                                  position: (307, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "https://example.com:8448/",
                                 },
                                ],
                                position: (307, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (308, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "The public-facing base URL for the client API (not including _matrix/...)\n",
                                 },
                                ],
                                position: (308, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (304, 39),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "tls_certificate_path",
                             position: (313, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (313, 36),
                           },
                           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: "nullOr",
                                    position: (314, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (314, 35),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "str",
                                     position: (314, 41),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (315, 15),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "null",
                                position: (315, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "example",
                                  position: (316, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "/var/lib/acme/example.com/fullchain.pem",
                                 },
                                ],
                                position: (316, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (317, 15),
                                 },
                                ],
                               },
                               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: (317, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (313, 45),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "tls_private_key_path",
                             position: (326, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (326, 36),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (327, 15),
                                 },
                                ],
                               },
                               FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (327, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "nullOr",
                                    position: (327, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (327, 35),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "str",
                                     position: (327, 41),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (328, 15),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "null",
                                position: (328, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "example",
                                  position: (329, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "/var/lib/acme/example.com/key.pem",
                                 },
                                ],
                                position: (329, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (330, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "PEM encoded private key for TLS. Specify null if synapse is not\nspeaking TLS directly.\n",
                                 },
                                ],
                                position: (330, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (326, 45),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "presence",
                             position: (336, 13),
                            },
                            Raw {
                             content: "enabled",
                             position: (336, 22),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (336, 32),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (337, 15),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (337, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "bool",
                                   position: (337, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (338, 15),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "true",
                                position: (338, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "example",
                                  position: (339, 15),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "false",
                                position: (339, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (340, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "Whether to enable presence tracking.\n\nPresence tracking allows users to see the state (e.g online/offline)\nof other local and remote users.\n",
                                 },
                                ],
                                position: (340, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (336, 41),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "listeners",
                             position: (348, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (348, 25),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (349, 15),
                                 },
                                ],
                               },
                               FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (349, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "listOf",
                                    position: (349, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 FunctionApplication {
                                  function: PropertyAccess {
                                   expression: Variable {
                                    identifier: "types",
                                    position: (349, 36),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "submodule",
                                      position: (349, 42),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  arguments: [
                                   Map {
                                    bindings: [
                                     KeyValue(
                                      AttributePath {
                                       attributes: [
                                        Raw {
                                         content: "options",
                                         position: (350, 17),
                                        },
                                       ],
                                      },
                                      Map {
                                       bindings: [
                                        KeyValue(
                                         AttributePath {
                                          attributes: [
                                           Raw {
                                            content: "port",
                                            position: (351, 19),
                                           },
                                          ],
                                         },
                                         FunctionApplication {
                                          function: Variable {
                                           identifier: "mkOption",
                                           position: (351, 26),
                                          },
                                          arguments: [
                                           Map {
                                            bindings: [
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "type",
                                                 position: (352, 21),
                                                },
                                               ],
                                              },
                                              PropertyAccess {
                                               expression: Variable {
                                                identifier: "types",
                                                position: (352, 28),
                                               },
                                               attribute_path: AttributePath {
                                                attributes: [
                                                 Raw {
                                                  content: "port",
                                                  position: (352, 34),
                                                 },
                                                ],
                                               },
                                               default: None,
                                              },
                                             ),
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "example",
                                                 position: (353, 21),
                                                },
                                               ],
                                              },
                                              Int {
                                               value: 8448,
                                               position: (353, 31),
                                              },
                                             ),
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "description",
                                                 position: (354, 21),
                                                },
                                               ],
                                              },
                                              String {
                                               parts: [
                                                Raw {
                                                 content: "The port to listen for HTTP(S) requests on.\n",
                                                },
                                               ],
                                               position: (354, 35),
                                              },
                                             ),
                                            ],
                                            recursive: false,
                                            position: (351, 35),
                                           },
                                          ],
                                         },
                                        ),
                                        KeyValue(
                                         AttributePath {
                                          attributes: [
                                           Raw {
                                            content: "bind_addresses",
                                            position: (359, 19),
                                           },
                                          ],
                                         },
                                         FunctionApplication {
                                          function: Variable {
                                           identifier: "mkOption",
                                           position: (359, 36),
                                          },
                                          arguments: [
                                           Map {
                                            bindings: [
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "type",
                                                 position: (360, 21),
                                                },
                                               ],
                                              },
                                              FunctionApplication {
                                               function: PropertyAccess {
                                                expression: Variable {
                                                 identifier: "types",
                                                 position: (360, 28),
                                                },
                                                attribute_path: AttributePath {
                                                 attributes: [
                                                  Raw {
                                                   content: "listOf",
                                                   position: (360, 34),
                                                  },
                                                 ],
                                                },
                                                default: None,
                                               },
                                               arguments: [
                                                PropertyAccess {
                                                 expression: Variable {
                                                  identifier: "types",
                                                  position: (360, 41),
                                                 },
                                                 attribute_path: AttributePath {
                                                  attributes: [
                                                   Raw {
                                                    content: "str",
                                                    position: (360, 47),
                                                   },
                                                  ],
                                                 },
                                                 default: None,
                                                },
                                               ],
                                              },
                                             ),
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "default",
                                                 position: (361, 21),
                                                },
                                               ],
                                              },
                                              List {
                                               elements: [
                                                String {
                                                 parts: [
                                                  Raw {
                                                   content: "::1",
                                                  },
                                                 ],
                                                 position: (362, 23),
                                                },
                                                String {
                                                 parts: [
                                                  Raw {
                                                   content: "127.0.0.1",
                                                  },
                                                 ],
                                                 position: (363, 23),
                                                },
                                               ],
                                               position: (361, 31),
                                              },
                                             ),
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "example",
                                                 position: (365, 21),
                                                },
                                               ],
                                              },
                                              FunctionApplication {
                                               function: Variable {
                                                identifier: "literalExpression",
                                                position: (365, 31),
                                               },
                                               arguments: [
                                                String {
                                                 parts: [
                                                  Raw {
                                                   content: "[\n  \"::\"\n  \"0.0.0.0\"\n]\n",
                                                  },
                                                 ],
                                                 position: (365, 49),
                                                },
                                               ],
                                              },
                                             ),
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "description",
                                                 position: (371, 21),
                                                },
                                               ],
                                              },
                                              String {
                                               parts: [
                                                Raw {
                                                 content: "IP addresses to bind the listener to.\n",
                                                },
                                               ],
                                               position: (371, 35),
                                              },
                                             ),
                                            ],
                                            recursive: false,
                                            position: (359, 45),
                                           },
                                          ],
                                         },
                                        ),
                                        KeyValue(
                                         AttributePath {
                                          attributes: [
                                           Raw {
                                            content: "type",
                                            position: (376, 19),
                                           },
                                          ],
                                         },
                                         FunctionApplication {
                                          function: Variable {
                                           identifier: "mkOption",
                                           position: (376, 26),
                                          },
                                          arguments: [
                                           Map {
                                            bindings: [
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "type",
                                                 position: (377, 21),
                                                },
                                               ],
                                              },
                                              FunctionApplication {
                                               function: PropertyAccess {
                                                expression: Variable {
                                                 identifier: "types",
                                                 position: (377, 28),
                                                },
                                                attribute_path: AttributePath {
                                                 attributes: [
                                                  Raw {
                                                   content: "enum",
                                                   position: (377, 34),
                                                  },
                                                 ],
                                                },
                                                default: None,
                                               },
                                               arguments: [
                                                List {
                                                 elements: [
                                                  String {
                                                   parts: [
                                                    Raw {
                                                     content: "http",
                                                    },
                                                   ],
                                                   position: (378, 23),
                                                  },
                                                  String {
                                                   parts: [
                                                    Raw {
                                                     content: "manhole",
                                                    },
                                                   ],
                                                   position: (379, 23),
                                                  },
                                                  String {
                                                   parts: [
                                                    Raw {
                                                     content: "metrics",
                                                    },
                                                   ],
                                                   position: (380, 23),
                                                  },
                                                  String {
                                                   parts: [
                                                    Raw {
                                                     content: "replication",
                                                    },
                                                   ],
                                                   position: (381, 23),
                                                  },
                                                 ],
                                                 position: (377, 39),
                                                },
                                               ],
                                              },
                                             ),
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "default",
                                                 position: (383, 21),
                                                },
                                               ],
                                              },
                                              String {
                                               parts: [
                                                Raw {
                                                 content: "http",
                                                },
                                               ],
                                               position: (383, 31),
                                              },
                                             ),
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "example",
                                                 position: (384, 21),
                                                },
                                               ],
                                              },
                                              String {
                                               parts: [
                                                Raw {
                                                 content: "metrics",
                                                },
                                               ],
                                               position: (384, 31),
                                              },
                                             ),
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "description",
                                                 position: (385, 21),
                                                },
                                               ],
                                              },
                                              String {
                                               parts: [
                                                Raw {
                                                 content: "The type of the listener, usually http.\n",
                                                },
                                               ],
                                               position: (385, 35),
                                              },
                                             ),
                                            ],
                                            recursive: false,
                                            position: (376, 35),
                                           },
                                          ],
                                         },
                                        ),
                                        KeyValue(
                                         AttributePath {
                                          attributes: [
                                           Raw {
                                            content: "tls",
                                            position: (390, 19),
                                           },
                                          ],
                                         },
                                         FunctionApplication {
                                          function: Variable {
                                           identifier: "mkOption",
                                           position: (390, 25),
                                          },
                                          arguments: [
                                           Map {
                                            bindings: [
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "type",
                                                 position: (391, 21),
                                                },
                                               ],
                                              },
                                              PropertyAccess {
                                               expression: Variable {
                                                identifier: "types",
                                                position: (391, 28),
                                               },
                                               attribute_path: AttributePath {
                                                attributes: [
                                                 Raw {
                                                  content: "bool",
                                                  position: (391, 34),
                                                 },
                                                ],
                                               },
                                               default: None,
                                              },
                                             ),
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "default",
                                                 position: (392, 21),
                                                },
                                               ],
                                              },
                                              Variable {
                                               identifier: "true",
                                               position: (392, 31),
                                              },
                                             ),
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "example",
                                                 position: (393, 21),
                                                },
                                               ],
                                              },
                                              Variable {
                                               identifier: "false",
                                               position: (393, 31),
                                              },
                                             ),
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "description",
                                                 position: (394, 21),
                                                },
                                               ],
                                              },
                                              String {
                                               parts: [
                                                Raw {
                                                 content: "Whether to enable TLS on the listener socket.\n",
                                                },
                                               ],
                                               position: (394, 35),
                                              },
                                             ),
                                            ],
                                            recursive: false,
                                            position: (390, 34),
                                           },
                                          ],
                                         },
                                        ),
                                        KeyValue(
                                         AttributePath {
                                          attributes: [
                                           Raw {
                                            content: "x_forwarded",
                                            position: (399, 19),
                                           },
                                          ],
                                         },
                                         FunctionApplication {
                                          function: Variable {
                                           identifier: "mkOption",
                                           position: (399, 33),
                                          },
                                          arguments: [
                                           Map {
                                            bindings: [
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "type",
                                                 position: (400, 21),
                                                },
                                               ],
                                              },
                                              PropertyAccess {
                                               expression: Variable {
                                                identifier: "types",
                                                position: (400, 28),
                                               },
                                               attribute_path: AttributePath {
                                                attributes: [
                                                 Raw {
                                                  content: "bool",
                                                  position: (400, 34),
                                                 },
                                                ],
                                               },
                                               default: None,
                                              },
                                             ),
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "default",
                                                 position: (401, 21),
                                                },
                                               ],
                                              },
                                              Variable {
                                               identifier: "false",
                                               position: (401, 31),
                                              },
                                             ),
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "example",
                                                 position: (402, 21),
                                                },
                                               ],
                                              },
                                              Variable {
                                               identifier: "true",
                                               position: (402, 31),
                                              },
                                             ),
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "description",
                                                 position: (403, 21),
                                                },
                                               ],
                                              },
                                              String {
                                               parts: [
                                                Raw {
                                                 content: "Use the X-Forwarded-For (XFF) header as the client IP and not the\nactual client IP.\n",
                                                },
                                               ],
                                               position: (403, 35),
                                              },
                                             ),
                                            ],
                                            recursive: false,
                                            position: (399, 42),
                                           },
                                          ],
                                         },
                                        ),
                                        KeyValue(
                                         AttributePath {
                                          attributes: [
                                           Raw {
                                            content: "resources",
                                            position: (409, 19),
                                           },
                                          ],
                                         },
                                         FunctionApplication {
                                          function: Variable {
                                           identifier: "mkOption",
                                           position: (409, 31),
                                          },
                                          arguments: [
                                           Map {
                                            bindings: [
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "type",
                                                 position: (410, 21),
                                                },
                                               ],
                                              },
                                              FunctionApplication {
                                               function: PropertyAccess {
                                                expression: Variable {
                                                 identifier: "types",
                                                 position: (410, 28),
                                                },
                                                attribute_path: AttributePath {
                                                 attributes: [
                                                  Raw {
                                                   content: "listOf",
                                                   position: (410, 34),
                                                  },
                                                 ],
                                                },
                                                default: None,
                                               },
                                               arguments: [
                                                FunctionApplication {
                                                 function: PropertyAccess {
                                                  expression: Variable {
                                                   identifier: "types",
                                                   position: (410, 42),
                                                  },
                                                  attribute_path: AttributePath {
                                                   attributes: [
                                                    Raw {
                                                     content: "submodule",
                                                     position: (410, 48),
                                                    },
                                                   ],
                                                  },
                                                  default: None,
                                                 },
                                                 arguments: [
                                                  Map {
                                                   bindings: [
                                                    KeyValue(
                                                     AttributePath {
                                                      attributes: [
                                                       Raw {
                                                        content: "options",
                                                        position: (411, 23),
                                                       },
                                                      ],
                                                     },
                                                     Map {
                                                      bindings: [
                                                       KeyValue(
                                                        AttributePath {
                                                         attributes: [
                                                          Raw {
                                                           content: "names",
                                                           position: (412, 25),
                                                          },
                                                         ],
                                                        },
                                                        FunctionApplication {
                                                         function: Variable {
                                                          identifier: "mkOption",
                                                          position: (412, 33),
                                                         },
                                                         arguments: [
                                                          Map {
                                                           bindings: [
                                                            KeyValue(
                                                             AttributePath {
                                                              attributes: [
                                                               Raw {
                                                                content: "type",
                                                                position: (413, 27),
                                                               },
                                                              ],
                                                             },
                                                             FunctionApplication {
                                                              function: PropertyAccess {
                                                               expression: Variable {
                                                                identifier: "types",
                                                                position: (413, 34),
                                                               },
                                                               attribute_path: AttributePath {
                                                                attributes: [
                                                                 Raw {
                                                                  content: "listOf",
                                                                  position: (413, 40),
                                                                 },
                                                                ],
                                                               },
                                                               default: None,
                                                              },
                                                              arguments: [
                                                               FunctionApplication {
                                                                function: PropertyAccess {
                                                                 expression: Variable {
                                                                  identifier: "types",
                                                                  position: (413, 48),
                                                                 },
                                                                 attribute_path: AttributePath {
                                                                  attributes: [
                                                                   Raw {
                                                                    content: "enum",
                                                                    position: (413, 54),
                                                                   },
                                                                  ],
                                                                 },
                                                                 default: None,
                                                                },
                                                                arguments: [
                                                                 List {
                                                                  elements: [
                                                                   String {
                                                                    parts: [
                                                                     Raw {
                                                                      content: "client",
                                                                     },
                                                                    ],
                                                                    position: (414, 29),
                                                                   },
                                                                   String {
                                                                    parts: [
                                                                     Raw {
                                                                      content: "consent",
                                                                     },
                                                                    ],
                                                                    position: (415, 29),
                                                                   },
                                                                   String {
                                                                    parts: [
                                                                     Raw {
                                                                      content: "federation",
                                                                     },
                                                                    ],
                                                                    position: (416, 29),
                                                                   },
                                                                   String {
                                                                    parts: [
                                                                     Raw {
                                                                      content: "keys",
                                                                     },
                                                                    ],
                                                                    position: (417, 29),
                                                                   },
                                                                   String {
                                                                    parts: [
                                                                     Raw {
                                                                      content: "media",
                                                                     },
                                                                    ],
                                                                    position: (418, 29),
                                                                   },
                                                                   String {
                                                                    parts: [
                                                                     Raw {
                                                                      content: "metrics",
                                                                     },
                                                                    ],
                                                                    position: (419, 29),
                                                                   },
                                                                   String {
                                                                    parts: [
                                                                     Raw {
                                                                      content: "openid",
                                                                     },
                                                                    ],
                                                                    position: (420, 29),
                                                                   },
                                                                   String {
                                                                    parts: [
                                                                     Raw {
                                                                      content: "replication",
                                                                     },
                                                                    ],
                                                                    position: (421, 29),
                                                                   },
                                                                   String {
                                                                    parts: [
                                                                     Raw {
                                                                      content: "static",
                                                                     },
                                                                    ],
                                                                    position: (422, 29),
                                                                   },
                                                                  ],
                                                                  position: (413, 59),
                                                                 },
                                                                ],
                                                               },
                                                              ],
                                                             },
                                                            ),
                                                            KeyValue(
                                                             AttributePath {
                                                              attributes: [
                                                               Raw {
                                                                content: "description",
                                                                position: (424, 27),
                                                               },
                                                              ],
                                                             },
                                                             String {
                                                              parts: [
                                                               Raw {
                                                                content: "List of resources to host on this listener.\n",
                                                               },
                                                              ],
                                                              position: (424, 41),
                                                             },
                                                            ),
                                                            KeyValue(
                                                             AttributePath {
                                                              attributes: [
                                                               Raw {
                                                                content: "example",
                                                                position: (427, 27),
                                                               },
                                                              ],
                                                             },
                                                             List {
                                                              elements: [
                                                               String {
                                                                parts: [
                                                                 Raw {
                                                                  content: "client",
                                                                 },
                                                                ],
                                                                position: (428, 29),
                                                               },
                                                              ],
                                                              position: (427, 37),
                                                             },
                                                            ),
                                                           ],
                                                           recursive: false,
                                                           position: (412, 42),
                                                          },
                                                         ],
                                                        },
                                                       ),
                                                       KeyValue(
                                                        AttributePath {
                                                         attributes: [
                                                          Raw {
                                                           content: "compress",
                                                           position: (431, 25),
                                                          },
                                                         ],
                                                        },
                                                        FunctionApplication {
                                                         function: Variable {
                                                          identifier: "mkOption",
                                                          position: (431, 36),
                                                         },
                                                         arguments: [
                                                          Map {
                                                           bindings: [
                                                            KeyValue(
                                                             AttributePath {
                                                              attributes: [
                                                               Raw {
                                                                content: "type",
                                                                position: (432, 27),
                                                               },
                                                              ],
                                                             },
                                                             PropertyAccess {
                                                              expression: Variable {
                                                               identifier: "types",
                                                               position: (432, 34),
                                                              },
                                                              attribute_path: AttributePath {
                                                               attributes: [
                                                                Raw {
                                                                 content: "bool",
                                                                 position: (432, 40),
                                                                },
                                                               ],
                                                              },
                                                              default: None,
                                                             },
                                                            ),
                                                            KeyValue(
                                                             AttributePath {
                                                              attributes: [
                                                               Raw {
                                                                content: "description",
                                                                position: (433, 27),
                                                               },
                                                              ],
                                                             },
                                                             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: (433, 41),
                                                             },
                                                            ),
                                                           ],
                                                           recursive: false,
                                                           position: (431, 45),
                                                          },
                                                         ],
                                                        },
                                                       ),
                                                      ],
                                                      recursive: false,
                                                      position: (411, 33),
                                                     },
                                                    ),
                                                   ],
                                                   recursive: false,
                                                   position: (410, 58),
                                                  },
                                                 ],
                                                },
                                               ],
                                              },
                                             ),
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "description",
                                                 position: (441, 21),
                                                },
                                               ],
                                              },
                                              String {
                                               parts: [
                                                Raw {
                                                 content: "List of HTTP resources to serve on this listener.\n",
                                                },
                                               ],
                                               position: (441, 35),
                                              },
                                             ),
                                            ],
                                            recursive: false,
                                            position: (409, 40),
                                           },
                                          ],
                                         },
                                        ),
                                       ],
                                       recursive: false,
                                       position: (350, 27),
                                      },
                                     ),
                                    ],
                                    recursive: false,
                                    position: (349, 52),
                                   },
                                  ],
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (447, 15),
                                 },
                                ],
                               },
                               List {
                                elements: [
                                 Map {
                                  bindings: [
                                   KeyValue(
                                    AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "port",
                                       position: (448, 17),
                                      },
                                     ],
                                    },
                                    Int {
                                     value: 8008,
                                     position: (448, 24),
                                    },
                                   ),
                                   KeyValue(
                                    AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "bind_addresses",
                                       position: (449, 17),
                                      },
                                     ],
                                    },
                                    List {
                                     elements: [
                                      String {
                                       parts: [
                                        Raw {
                                         content: "127.0.0.1",
                                        },
                                       ],
                                       position: (449, 36),
                                      },
                                     ],
                                     position: (449, 34),
                                    },
                                   ),
                                   KeyValue(
                                    AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "type",
                                       position: (450, 17),
                                      },
                                     ],
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "http",
                                      },
                                     ],
                                     position: (450, 24),
                                    },
                                   ),
                                   KeyValue(
                                    AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "tls",
                                       position: (451, 17),
                                      },
                                     ],
                                    },
                                    Variable {
                                     identifier: "false",
                                     position: (451, 23),
                                    },
                                   ),
                                   KeyValue(
                                    AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "x_forwarded",
                                       position: (452, 17),
                                      },
                                     ],
                                    },
                                    Variable {
                                     identifier: "true",
                                     position: (452, 31),
                                    },
                                   ),
                                   KeyValue(
                                    AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "resources",
                                       position: (453, 17),
                                      },
                                     ],
                                    },
                                    List {
                                     elements: [
                                      Map {
                                       bindings: [
                                        KeyValue(
                                         AttributePath {
                                          attributes: [
                                           Raw {
                                            content: "names",
                                            position: (454, 19),
                                           },
                                          ],
                                         },
                                         List {
                                          elements: [
                                           String {
                                            parts: [
                                             Raw {
                                              content: "client",
                                             },
                                            ],
                                            position: (454, 29),
                                           },
                                          ],
                                          position: (454, 27),
                                         },
                                        ),
                                        KeyValue(
                                         AttributePath {
                                          attributes: [
                                           Raw {
                                            content: "compress",
                                            position: (455, 19),
                                           },
                                          ],
                                         },
                                         Variable {
                                          identifier: "true",
                                          position: (455, 30),
                                         },
                                        ),
                                       ],
                                       recursive: false,
                                       position: (453, 31),
                                      },
                                      Map {
                                       bindings: [
                                        KeyValue(
                                         AttributePath {
                                          attributes: [
                                           Raw {
                                            content: "names",
                                            position: (457, 19),
                                           },
                                          ],
                                         },
                                         List {
                                          elements: [
                                           String {
                                            parts: [
                                             Raw {
                                              content: "federation",
                                             },
                                            ],
                                            position: (457, 29),
                                           },
                                          ],
                                          position: (457, 27),
                                         },
                                        ),
                                        KeyValue(
                                         AttributePath {
                                          attributes: [
                                           Raw {
                                            content: "compress",
                                            position: (458, 19),
                                           },
                                          ],
                                         },
                                         Variable {
                                          identifier: "false",
                                          position: (458, 30),
                                         },
                                        ),
                                       ],
                                       recursive: false,
                                       position: (456, 19),
                                      },
                                     ],
                                     position: (453, 29),
                                    },
                                   ),
                                  ],
                                  recursive: false,
                                  position: (447, 27),
                                 },
                                ],
                                position: (447, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (461, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "List of ports that Synapse should listen on, their purpose and their configuration.\n",
                                 },
                                ],
                                position: (461, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (348, 34),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "database",
                             position: (466, 13),
                            },
                            Raw {
                             content: "name",
                             position: (466, 22),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (466, 29),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (467, 15),
                                 },
                                ],
                               },
                               FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (467, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "enum",
                                    position: (467, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 List {
                                  elements: [
                                   String {
                                    parts: [
                                     Raw {
                                      content: "sqlite3",
                                     },
                                    ],
                                    position: (468, 17),
                                   },
                                   String {
                                    parts: [
                                     Raw {
                                      content: "psycopg2",
                                     },
                                    ],
                                    position: (469, 17),
                                   },
                                  ],
                                  position: (467, 33),
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (471, 15),
                                 },
                                ],
                               },
                               IfThenElse {
                                predicate: FunctionApplication {
                                 function: Variable {
                                  identifier: "versionAtLeast",
                                  position: (471, 28),
                                 },
                                 arguments: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "config",
                                    position: (471, 43),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "system",
                                      position: (471, 50),
                                     },
                                     Raw {
                                      content: "stateVersion",
                                      position: (471, 57),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  String {
                                   parts: [
                                    Raw {
                                     content: "18.03",
                                    },
                                   ],
                                   position: (471, 70),
                                  },
                                 ],
                                },
                                then: String {
                                 parts: [
                                  Raw {
                                   content: "psycopg2",
                                  },
                                 ],
                                 position: (472, 22),
                                },
                                else_: String {
                                 parts: [
                                  Raw {
                                   content: "sqlite3",
                                  },
                                 ],
                                 position: (473, 22),
                                },
                                position: (471, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "defaultText",
                                  position: (474, 16),
                                 },
                                ],
                               },
                               FunctionApplication {
                                function: Variable {
                                 identifier: "literalExpression",
                                 position: (474, 30),
                                },
                                arguments: [
                                 String {
                                  parts: [
                                   Raw {
                                    content: "if versionAtLeast config.system.stateVersion \"18.03\"\nthen \"psycopg2\"\nelse \"sqlite3\"\n",
                                   },
                                  ],
                                  position: (474, 48),
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (479, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "The database engine name. Can be sqlite3 or psycopg2.\n",
                                 },
                                ],
                                position: (479, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (466, 38),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "database",
                             position: (484, 13),
                            },
                            Raw {
                             content: "args",
                             position: (484, 22),
                            },
                            Raw {
                             content: "database",
                             position: (484, 27),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (484, 38),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (485, 15),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (485, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "str",
                                   position: (485, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (486, 15),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Map {
                                 bindings: [
                                  KeyValue(
                                   AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "sqlite3",
                                      position: (487, 17),
                                     },
                                    ],
                                   },
                                   String {
                                    parts: [
                                     Expression {
                                      expression: PropertyAccess {
                                       expression: Variable {
                                        identifier: "cfg",
                                        position: (487, 30),
                                       },
                                       attribute_path: AttributePath {
                                        attributes: [
                                         Raw {
                                          content: "dataDir",
                                          position: (487, 34),
                                         },
                                        ],
                                       },
                                       default: None,
                                      },
                                     },
                                     Raw {
                                      content: "/homeserver.db",
                                     },
                                    ],
                                    position: (487, 27),
                                   },
                                  ),
                                  KeyValue(
                                   AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "psycopg2",
                                      position: (488, 17),
                                     },
                                    ],
                                   },
                                   String {
                                    parts: [
                                     Raw {
                                      content: "matrix-synapse",
                                     },
                                    ],
                                    position: (488, 28),
                                   },
                                  ),
                                 ],
                                 recursive: false,
                                 position: (486, 25),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Expression {
                                   expression: PropertyAccess {
                                    expression: Variable {
                                     identifier: "cfg",
                                     position: (489, 19),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "settings",
                                       position: (489, 23),
                                      },
                                      Raw {
                                       content: "database",
                                       position: (489, 32),
                                      },
                                      Raw {
                                       content: "name",
                                       position: (489, 41),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "defaultText",
                                  position: (490, 15),
                                 },
                                ],
                               },
                               FunctionApplication {
                                function: Variable {
                                 identifier: "literalExpression",
                                 position: (490, 29),
                                },
                                arguments: [
                                 String {
                                  parts: [
                                   Raw {
                                    content: "{\n  sqlite3 = \"",
                                   },
                                   Raw {
                                    content: "$",
                                   },
                                   Raw {
                                    content: "{",
                                   },
                                   Expression {
                                    expression: PropertyAccess {
                                     expression: Variable {
                                      identifier: "options",
                                      position: (492, 34),
                                     },
                                     attribute_path: AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "services",
                                        position: (492, 42),
                                       },
                                       Raw {
                                        content: "matrix-synapse",
                                        position: (492, 51),
                                       },
                                       Raw {
                                        content: "dataDir",
                                        position: (492, 66),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                   },
                                   Raw {
                                    content: "}/homeserver.db\";\n  psycopg2 = \"matrix-synapse\";\n}.",
                                   },
                                   Raw {
                                    content: "$",
                                   },
                                   Raw {
                                    content: "{",
                                   },
                                   Expression {
                                    expression: PropertyAccess {
                                     expression: Variable {
                                      identifier: "options",
                                      position: (494, 23),
                                     },
                                     attribute_path: AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "services",
                                        position: (494, 31),
                                       },
                                       Raw {
                                        content: "matrix-synapse",
                                        position: (494, 40),
                                       },
                                       Raw {
                                        content: "settings",
                                        position: (494, 55),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                   },
                                   Raw {
                                    content: ".database.name};\n",
                                   },
                                  ],
                                  position: (490, 47),
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (496, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "Name of the database when using the psycopg2 backend,\npath to the database location when using sqlite3.\n",
                                 },
                                ],
                                position: (496, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (484, 47),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "database",
                             position: (502, 13),
                            },
                            Raw {
                             content: "args",
                             position: (502, 22),
                            },
                            Raw {
                             content: "user",
                             position: (502, 27),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (502, 34),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (503, 15),
                                 },
                                ],
                               },
                               FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (503, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "nullOr",
                                    position: (503, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (503, 35),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "str",
                                     position: (503, 41),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (504, 15),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Map {
                                 bindings: [
                                  KeyValue(
                                   AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "sqlite3",
                                      position: (505, 17),
                                     },
                                    ],
                                   },
                                   Variable {
                                    identifier: "null",
                                    position: (505, 27),
                                   },
                                  ),
                                  KeyValue(
                                   AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "psycopg2",
                                      position: (506, 17),
                                     },
                                    ],
                                   },
                                   String {
                                    parts: [
                                     Raw {
                                      content: "matrix-synapse",
                                     },
                                    ],
                                    position: (506, 28),
                                   },
                                  ),
                                 ],
                                 recursive: false,
                                 position: (504, 25),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Expression {
                                   expression: PropertyAccess {
                                    expression: Variable {
                                     identifier: "cfg",
                                     position: (507, 19),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "settings",
                                       position: (507, 23),
                                      },
                                      Raw {
                                       content: "database",
                                       position: (507, 32),
                                      },
                                      Raw {
                                       content: "name",
                                       position: (507, 41),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (508, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "Username to connect with psycopg2, set to null\nwhen using sqlite3.\n",
                                 },
                                ],
                                position: (508, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (502, 43),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "url_preview_enabled",
                             position: (514, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (514, 35),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (515, 15),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (515, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "bool",
                                   position: (515, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (516, 15),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "true",
                                position: (516, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "example",
                                  position: (517, 15),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "false",
                                position: (517, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (518, 15),
                                 },
                                ],
                               },
                               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: (518, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (514, 44),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "url_preview_ip_range_blacklist",
                             position: (525, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (525, 46),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (526, 15),
                                 },
                                ],
                               },
                               FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (526, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "listOf",
                                    position: (526, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (526, 35),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "str",
                                     position: (526, 41),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (527, 15),
                                 },
                                ],
                               },
                               List {
                                elements: [
                                 String {
                                  parts: [
                                   Raw {
                                    content: "10.0.0.0/8",
                                   },
                                  ],
                                  position: (528, 17),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "100.64.0.0/10",
                                   },
                                  ],
                                  position: (529, 17),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "127.0.0.0/8",
                                   },
                                  ],
                                  position: (530, 17),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "169.254.0.0/16",
                                   },
                                  ],
                                  position: (531, 17),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "172.16.0.0/12",
                                   },
                                  ],
                                  position: (532, 17),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "192.0.0.0/24",
                                   },
                                  ],
                                  position: (533, 17),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "192.0.2.0/24",
                                   },
                                  ],
                                  position: (534, 17),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "192.168.0.0/16",
                                   },
                                  ],
                                  position: (535, 17),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "192.88.99.0/24",
                                   },
                                  ],
                                  position: (536, 17),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "198.18.0.0/15",
                                   },
                                  ],
                                  position: (537, 17),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "198.51.100.0/24",
                                   },
                                  ],
                                  position: (538, 17),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "2001:db8::/32",
                                   },
                                  ],
                                  position: (539, 17),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "203.0.113.0/24",
                                   },
                                  ],
                                  position: (540, 17),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "224.0.0.0/4",
                                   },
                                  ],
                                  position: (541, 17),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "::1/128",
                                   },
                                  ],
                                  position: (542, 17),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "fc00::/7",
                                   },
                                  ],
                                  position: (543, 17),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "fe80::/10",
                                   },
                                  ],
                                  position: (544, 17),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "fec0::/10",
                                   },
                                  ],
                                  position: (545, 17),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "ff00::/8",
                                   },
                                  ],
                                  position: (546, 17),
                                 },
                                ],
                                position: (527, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (548, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "List of IP address CIDR ranges that the URL preview spider is denied\nfrom accessing.\n",
                                 },
                                ],
                                position: (548, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (525, 55),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "url_preview_ip_range_whitelist",
                             position: (554, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (554, 46),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (555, 15),
                                 },
                                ],
                               },
                               FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (555, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "listOf",
                                    position: (555, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (555, 35),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "str",
                                     position: (555, 41),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (556, 15),
                                 },
                                ],
                               },
                               List {
                                elements: [],
                                position: (556, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (557, 15),
                                 },
                                ],
                               },
                               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 url_preview_ip_range_blacklist.\n",
                                 },
                                ],
                                position: (557, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (554, 55),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "url_preview_url_blacklist",
                             position: (563, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (563, 41),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (564, 15),
                                 },
                                ],
                               },
                               FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (564, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "listOf",
                                    position: (564, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (564, 35),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "str",
                                     position: (564, 41),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (565, 15),
                                 },
                                ],
                               },
                               List {
                                elements: [],
                                position: (565, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (566, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "Optional list of URL matches that the URL preview spider is\ndenied from accessing.\n",
                                 },
                                ],
                                position: (566, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (563, 50),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "max_upload_size",
                             position: (572, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (572, 31),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (573, 15),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (573, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "str",
                                   position: (573, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (574, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "50M",
                                 },
                                ],
                                position: (574, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "example",
                                  position: (575, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "100M",
                                 },
                                ],
                                position: (575, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (576, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "The largest allowed upload size in bytes\n",
                                 },
                                ],
                                position: (576, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (572, 40),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "max_image_pixels",
                             position: (581, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (581, 32),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (582, 15),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (582, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "str",
                                   position: (582, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (583, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "32M",
                                 },
                                ],
                                position: (583, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "example",
                                  position: (584, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "64M",
                                 },
                                ],
                                position: (584, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (585, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "Maximum number of pixels that will be thumbnailed\n",
                                 },
                                ],
                                position: (585, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (581, 41),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "dynamic_thumbnails",
                             position: (590, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (590, 34),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (591, 15),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (591, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "bool",
                                   position: (591, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (592, 15),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "false",
                                position: (592, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "example",
                                  position: (593, 15),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "true",
                                position: (593, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (594, 15),
                                 },
                                ],
                               },
                               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: (594, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (590, 43),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "turn_uris",
                             position: (603, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (603, 25),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (604, 15),
                                 },
                                ],
                               },
                               FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (604, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "listOf",
                                    position: (604, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (604, 35),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "str",
                                     position: (604, 41),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (605, 15),
                                 },
                                ],
                               },
                               List {
                                elements: [],
                                position: (605, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "example",
                                  position: (606, 15),
                                 },
                                ],
                               },
                               List {
                                elements: [
                                 String {
                                  parts: [
                                   Raw {
                                    content: "turn:turn.example.com:3487?transport=udp",
                                   },
                                  ],
                                  position: (607, 17),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "turn:turn.example.com:3487?transport=tcp",
                                   },
                                  ],
                                  position: (608, 17),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "turns:turn.example.com:5349?transport=udp",
                                   },
                                  ],
                                  position: (609, 17),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "turns:turn.example.com:5349?transport=tcp",
                                   },
                                  ],
                                  position: (610, 17),
                                 },
                                ],
                                position: (606, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (612, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "The public URIs of the TURN server to give to clients\n",
                                 },
                                ],
                                position: (612, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (603, 34),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "turn_shared_secret",
                             position: (616, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (616, 34),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (617, 15),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (617, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "str",
                                   position: (617, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (618, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [],
                                position: (618, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "example",
                                  position: (619, 15),
                                 },
                                ],
                               },
                               FunctionApplication {
                                function: Variable {
                                 identifier: "literalExpression",
                                 position: (619, 25),
                                },
                                arguments: [
                                 String {
                                  parts: [
                                   Raw {
                                    content: "config.services.coturn.static-auth-secret\n",
                                   },
                                  ],
                                  position: (619, 43),
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (622, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "The shared secret used to compute passwords for the TURN server.\n\nSecrets should be passed in via <literal>extraConfigFiles</literal>!\n",
                                 },
                                ],
                                position: (622, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (616, 43),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "trusted_key_servers",
                             position: (629, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (629, 35),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (630, 15),
                                 },
                                ],
                               },
                               FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (630, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "listOf",
                                    position: (630, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 FunctionApplication {
                                  function: PropertyAccess {
                                   expression: Variable {
                                    identifier: "types",
                                    position: (630, 36),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "submodule",
                                      position: (630, 42),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  arguments: [
                                   Map {
                                    bindings: [
                                     KeyValue(
                                      AttributePath {
                                       attributes: [
                                        Raw {
                                         content: "options",
                                         position: (631, 17),
                                        },
                                       ],
                                      },
                                      Map {
                                       bindings: [
                                        KeyValue(
                                         AttributePath {
                                          attributes: [
                                           Raw {
                                            content: "server_name",
                                            position: (632, 19),
                                           },
                                          ],
                                         },
                                         FunctionApplication {
                                          function: Variable {
                                           identifier: "mkOption",
                                           position: (632, 33),
                                          },
                                          arguments: [
                                           Map {
                                            bindings: [
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "type",
                                                 position: (633, 21),
                                                },
                                               ],
                                              },
                                              PropertyAccess {
                                               expression: Variable {
                                                identifier: "types",
                                                position: (633, 28),
                                               },
                                               attribute_path: AttributePath {
                                                attributes: [
                                                 Raw {
                                                  content: "str",
                                                  position: (633, 34),
                                                 },
                                                ],
                                               },
                                               default: None,
                                              },
                                             ),
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "example",
                                                 position: (634, 21),
                                                },
                                               ],
                                              },
                                              String {
                                               parts: [
                                                Raw {
                                                 content: "matrix.org",
                                                },
                                               ],
                                               position: (634, 31),
                                              },
                                             ),
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "description",
                                                 position: (635, 21),
                                                },
                                               ],
                                              },
                                              String {
                                               parts: [
                                                Raw {
                                                 content: "Hostname of the trusted server.\n",
                                                },
                                               ],
                                               position: (635, 35),
                                              },
                                             ),
                                            ],
                                            recursive: false,
                                            position: (632, 42),
                                           },
                                          ],
                                         },
                                        ),
                                        KeyValue(
                                         AttributePath {
                                          attributes: [
                                           Raw {
                                            content: "verify_keys",
                                            position: (640, 19),
                                           },
                                          ],
                                         },
                                         FunctionApplication {
                                          function: Variable {
                                           identifier: "mkOption",
                                           position: (640, 33),
                                          },
                                          arguments: [
                                           Map {
                                            bindings: [
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "type",
                                                 position: (641, 21),
                                                },
                                               ],
                                              },
                                              FunctionApplication {
                                               function: PropertyAccess {
                                                expression: Variable {
                                                 identifier: "types",
                                                 position: (641, 28),
                                                },
                                                attribute_path: AttributePath {
                                                 attributes: [
                                                  Raw {
                                                   content: "nullOr",
                                                   position: (641, 34),
                                                  },
                                                 ],
                                                },
                                                default: None,
                                               },
                                               arguments: [
                                                FunctionApplication {
                                                 function: PropertyAccess {
                                                  expression: Variable {
                                                   identifier: "types",
                                                   position: (641, 42),
                                                  },
                                                  attribute_path: AttributePath {
                                                   attributes: [
                                                    Raw {
                                                     content: "attrsOf",
                                                     position: (641, 48),
                                                    },
                                                   ],
                                                  },
                                                  default: None,
                                                 },
                                                 arguments: [
                                                  PropertyAccess {
                                                   expression: Variable {
                                                    identifier: "types",
                                                    position: (641, 56),
                                                   },
                                                   attribute_path: AttributePath {
                                                    attributes: [
                                                     Raw {
                                                      content: "str",
                                                      position: (641, 62),
                                                     },
                                                    ],
                                                   },
                                                   default: None,
                                                  },
                                                 ],
                                                },
                                               ],
                                              },
                                             ),
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "default",
                                                 position: (642, 21),
                                                },
                                               ],
                                              },
                                              Variable {
                                               identifier: "null",
                                               position: (642, 31),
                                              },
                                             ),
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "example",
                                                 position: (643, 21),
                                                },
                                               ],
                                              },
                                              FunctionApplication {
                                               function: Variable {
                                                identifier: "literalExpression",
                                                position: (643, 31),
                                               },
                                               arguments: [
                                                String {
                                                 parts: [
                                                  Raw {
                                                   content: "{\n  \"ed25519:auto\" = \"Noi6WqcDj0QmPxCNQqgezwTlBKrfqehY1u2FyWP9uYw\";\n}\n",
                                                  },
                                                 ],
                                                 position: (643, 49),
                                                },
                                               ],
                                              },
                                             ),
                                             KeyValue(
                                              AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "description",
                                                 position: (648, 21),
                                                },
                                               ],
                                              },
                                              String {
                                               parts: [
                                                Raw {
                                                 content: "Attribute set from key id to base64 encoded public key.\n\nIf specified synapse will check that the response is signed\nby at least one of the given keys.\n",
                                                },
                                               ],
                                               position: (648, 35),
                                              },
                                             ),
                                            ],
                                            recursive: false,
                                            position: (640, 42),
                                           },
                                          ],
                                         },
                                        ),
                                       ],
                                       recursive: false,
                                       position: (631, 27),
                                      },
                                     ),
                                    ],
                                    recursive: false,
                                    position: (630, 52),
                                   },
                                  ],
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (657, 15),
                                 },
                                ],
                               },
                               List {
                                elements: [
                                 Map {
                                  bindings: [
                                   KeyValue(
                                    AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "server_name",
                                       position: (658, 17),
                                      },
                                     ],
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "matrix.org",
                                      },
                                     ],
                                     position: (658, 31),
                                    },
                                   ),
                                   KeyValue(
                                    AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "verify_keys",
                                       position: (659, 17),
                                      },
                                     ],
                                    },
                                    Map {
                                     bindings: [
                                      KeyValue(
                                       AttributePath {
                                        attributes: [
                                         Expression {
                                          expression: __StringParts(
                                           [
                                            Raw {
                                             content: "ed25519:auto",
                                            },
                                           ],
                                          ),
                                         },
                                        ],
                                       },
                                       String {
                                        parts: [
                                         Raw {
                                          content: "Noi6WqcDj0QmPxCNQqgezwTlBKrfqehY1u2FyWP9uYw",
                                         },
                                        ],
                                        position: (660, 36),
                                       },
                                      ),
                                     ],
                                     recursive: false,
                                     position: (659, 31),
                                    },
                                   ),
                                  ],
                                  recursive: false,
                                  position: (657, 27),
                                 },
                                ],
                                position: (657, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (663, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "The trusted servers to download signing keys from.\n",
                                 },
                                ],
                                position: (663, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (629, 44),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "app_service_config_files",
                             position: (668, 13),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (668, 40),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (669, 15),
                                 },
                                ],
                               },
                               FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (669, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "listOf",
                                    position: (669, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (669, 35),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "path",
                                     position: (669, 41),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (670, 15),
                                 },
                                ],
                               },
                               List {
                                elements: [],
                                position: (670, 25),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (671, 15),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "A list of application service config file to use\n",
                                 },
                                ],
                                position: (671, 29),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (668, 49),
                            },
                           ],
                          },
                         ),
                        ],
                        recursive: false,
                        position: (203, 21),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (201, 38),
                    },
                   ],
                  },
                  position: (201, 16),
                 },
                ),
               ],
               recursive: false,
               position: (192, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraConfigFiles",
               position: (680, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (680, 26),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (681, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (681, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (681, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (681, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "path",
                       position: (681, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (682, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (682, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (683, 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: (683, 23),
                 },
                ),
               ],
               recursive: false,
               position: (680, 35),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (140, 31),
         },
        ),
       ],
       recursive: false,
       position: (139, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (695, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (695, 12),
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (695, 17),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (695, 21),
           },
          ],
         },
         default: None,
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "assertions",
              position: (696, 5),
             },
            ],
           },
           List {
            elements: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (697, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Implication,
                 operands: [
                  Variable {
                   identifier: "hasLocalPostgresDB",
                   position: (697, 21),
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (697, 43),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "services",
                      position: (697, 50),
                     },
                     Raw {
                      content: "postgresql",
                      position: (697, 59),
                     },
                     Raw {
                      content: "enable",
                      position: (697, 70),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (697, 40),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (698, 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: (698, 19),
                },
               ),
              ],
              recursive: false,
              position: (697, 7),
             },
            ],
            position: (696, 18),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (715, 5),
             },
             Raw {
              content: "matrix-synapse",
              position: (715, 14),
             },
             Raw {
              content: "configFile",
              position: (715, 29),
             },
            ],
           },
           Variable {
            identifier: "configFile",
            position: (715, 42),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (717, 5),
             },
             Raw {
              content: "users",
              position: (717, 11),
             },
             Raw {
              content: "matrix-synapse",
              position: (717, 17),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "group",
                 position: (718, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "matrix-synapse",
                },
               ],
               position: (718, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "home",
                 position: (719, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (719, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "dataDir",
                  position: (719, 18),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "createHome",
                 position: (720, 7),
                },
               ],
              },
              Variable {
               identifier: "true",
               position: (720, 20),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "shell",
                 position: (721, 7),
                },
               ],
              },
              String {
               parts: [
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (721, 18),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bash",
                     position: (721, 23),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "/bin/bash",
                },
               ],
               position: (721, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "uid",
                 position: (722, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (722, 13),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "ids",
                  position: (722, 20),
                 },
                 Raw {
                  content: "uids",
                  position: (722, 24),
                 },
                 Raw {
                  content: "matrix-synapse",
                  position: (722, 29),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (717, 34),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (725, 5),
             },
             Raw {
              content: "groups",
              position: (725, 11),
             },
             Raw {
              content: "matrix-synapse",
              position: (725, 18),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "gid",
                 position: (726, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (726, 13),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "ids",
                  position: (726, 20),
                 },
                 Raw {
                  content: "gids",
                  position: (726, 24),
                 },
                 Raw {
                  content: "matrix-synapse",
                  position: (726, 29),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (725, 35),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (729, 5),
             },
             Raw {
              content: "services",
              position: (729, 13),
             },
             Raw {
              content: "matrix-synapse",
              position: (729, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (730, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Synapse Matrix homeserver",
                },
               ],
               position: (730, 21),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "after",
                 position: (731, 7),
                },
               ],
              },
              BinaryOperation {
               operator: Concatenation,
               operands: [
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "network.target",
                    },
                   ],
                   position: (731, 17),
                  },
                 ],
                 position: (731, 15),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "optional",
                  position: (731, 39),
                 },
                 arguments: [
                  Variable {
                   identifier: "hasLocalPostgresDB",
                   position: (731, 48),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "postgresql.service",
                    },
                   ],
                   position: (731, 67),
                  },
                 ],
                },
               ],
               position: (731, 36),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wantedBy",
                 position: (732, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "multi-user.target",
                  },
                 ],
                 position: (732, 20),
                },
               ],
               position: (732, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "preStart",
                 position: (733, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "",
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (734, 11),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (734, 15),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "/bin/synapse_homeserver \\\n  --config-path ",
                },
                Expression {
                 expression: Variable {
                  identifier: "configFile",
                  position: (735, 27),
                 },
                },
                Raw {
                 content: " \\\n  --keys-directory ",
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (736, 30),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "dataDir",
                     position: (736, 34),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: " \\\n  --generate-keys\n",
                },
               ],
               position: (733, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "environment",
                 position: (739, 7),
                },
               ],
              },
              BinaryOperation {
               operator: Update,
               operands: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "PYTHONPATH",
                      position: (740, 9),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "makeSearchPathOutput",
                     position: (740, 22),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "lib",
                       },
                      ],
                      position: (740, 43),
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (740, 49),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "package",
                         position: (740, 53),
                        },
                        Raw {
                         content: "python",
                         position: (740, 61),
                        },
                        Raw {
                         content: "sitePackages",
                         position: (740, 68),
                        },
                       ],
                      },
                      default: None,
                     },
                     List {
                      elements: [
                       Variable {
                        identifier: "pluginsEnv",
                        position: (740, 83),
                       },
                      ],
                      position: (740, 81),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (739, 21),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "optionalAttrs",
                  position: (741, 12),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (741, 27),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "withJemalloc",
                      position: (741, 31),
                     },
                    ],
                   },
                   default: None,
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "LD_PRELOAD",
                        position: (742, 9),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "pkgs",
                          position: (742, 25),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "jemalloc",
                            position: (742, 30),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/lib/libjemalloc.so",
                       },
                      ],
                      position: (742, 22),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (741, 45),
                  },
                 ],
                },
               ],
               position: (741, 9),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (744, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Type",
                    position: (745, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "notify",
                   },
                  ],
                  position: (745, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "User",
                    position: (746, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "matrix-synapse",
                   },
                  ],
                  position: (746, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Group",
                    position: (747, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "matrix-synapse",
                   },
                  ],
                  position: (747, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "WorkingDirectory",
                    position: (748, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (748, 28),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "dataDir",
                     position: (748, 32),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStartPre",
                    position: (749, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   BinaryOperation {
                    operator: Addition,
                    operands: [
                     String {
                      parts: [
                       Raw {
                        content: "+",
                       },
                      ],
                      position: (749, 27),
                     },
                     FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (749, 34),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "writeShellScript",
                          position: (749, 39),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "matrix-synapse-fix-permissions",
                         },
                        ],
                        position: (749, 56),
                       },
                       String {
                        parts: [
                         Raw {
                          content: "chown matrix-synapse:matrix-synapse ",
                         },
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (750, 49),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "dataDir",
                              position: (750, 53),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: "/homeserver.signing.key\nchmod 0600 ",
                         },
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (751, 24),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "dataDir",
                              position: (751, 28),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: "/homeserver.signing.key\n",
                         },
                        ],
                        position: (749, 89),
                       },
                      ],
                     },
                    ],
                    position: (749, 31),
                   },
                  ],
                  position: (749, 24),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStart",
                    position: (753, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "",
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (754, 13),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "package",
                        position: (754, 17),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/bin/synapse_homeserver \\\n  ",
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "concatMapStringsSep",
                      position: (755, 16),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "\n  ",
                        },
                       ],
                       position: (755, 36),
                      },
                      Function {
                       argument: Some(
                        "x",
                       ),
                       arguments: FunctionArguments {
                        arguments: [],
                        ellipsis: false,
                       },
                       definition: String {
                        parts: [
                         Raw {
                          content: "--config-path ",
                         },
                         Expression {
                          expression: Variable {
                           identifier: "x",
                           position: (755, 64),
                          },
                         },
                         Raw {
                          content: " \\",
                         },
                        ],
                        position: (755, 47),
                       },
                       position: (755, 44),
                      },
                      BinaryOperation {
                       operator: Concatenation,
                       operands: [
                        List {
                         elements: [
                          Variable {
                           identifier: "configFile",
                           position: (755, 75),
                          },
                         ],
                         position: (755, 73),
                        },
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (755, 91),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "extraConfigFiles",
                            position: (755, 95),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                       position: (755, 88),
                      },
                     ],
                    },
                   },
                   Raw {
                    content: "\n  --keys-directory ",
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (756, 32),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "dataDir",
                        position: (756, 36),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\n",
                   },
                  ],
                  position: (753, 21),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecReload",
                    position: (758, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "pkgs",
                      position: (758, 25),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "util-linux",
                        position: (758, 30),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/bin/kill -HUP $MAINPID",
                   },
                  ],
                  position: (758, 22),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Restart",
                    position: (759, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "on-failure",
                   },
                  ],
                  position: (759, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "UMask",
                    position: (760, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "0077",
                   },
                  ],
                  position: (760, 17),
                 },
                ),
               ],
               recursive: false,
               position: (744, 23),
              },
             ),
            ],
            recursive: false,
            position: (729, 39),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (764, 5),
             },
             Raw {
              content: "systemPackages",
              position: (764, 17),
             },
            ],
           },
           List {
            elements: [
             Variable {
              identifier: "registerNewMatrixUser",
              position: (764, 36),
             },
            ],
            position: (764, 34),
           },
          ),
         ],
         recursive: false,
         position: (695, 28),
        },
       ],
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "meta",
         position: (767, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "buildDocsInSandbox",
            position: (768, 5),
           },
          ],
         },
         Variable {
          identifier: "false",
          position: (768, 26),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "doc",
            position: (769, 5),
           },
          ],
         },
         Path {
          parts: [
           Raw {
            content: "./matrix-synapse.xml",
           },
          ],
          position: (769, 11),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "maintainers",
            position: (770, 5),
           },
          ],
         },
         PropertyAccess {
          expression: Variable {
           identifier: "teams",
           position: (770, 19),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "matrix",
             position: (770, 25),
            },
            Raw {
             content: "members",
             position: (770, 32),
            },
           ],
          },
          default: None,
         },
        ),
       ],
       recursive: false,
       position: (767, 10),
      },
     ),
    ],
    recursive: false,
    position: (53, 4),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}