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